Почему конструктор прототипа ссылается на самого себя?

Если вы хотите найти цепочку прототипов, описанную там:

Each object has a private property which holds a link to another object called its prototype. That prototype object has a prototype of its own, and so on until an object is reached with null as its prototype. By definition, null has no prototype, and acts as the final link in this prototype chain.

Вы должны посмотреть на свойства __proto__ (которые будут указывать на внутренний прототип исследуемого объекта).

Здесь вы видите, что внутренним прототипом myFunctionObj является Function.prototype, и переход на следующий уровень __proto__ приводит вас к Object.prototype, у которого нет __proto__ (конец цепочки прототипов).

Свойство prototypemyFunctionObj относится к внутреннему прототипу созданные объекты (например, const obj = new myFunctionObj();, а затем obj.__proto__ === myFunctionObj.prototype), а не к внутреннему прототипу самого myFunctionObj.

Обычно только function имеют свойство .prototype, и их .prototype будет ссылаться на внутренний прототип экземпляров, созданных с помощью new. Простые объекты не имеют свойства .prototype (поскольку простые объекты нельзя вызывать для создания чего-либо), но вы все равно можете получить доступ к внутреннему прототипу простого объекта (или чего-либо еще) с помощью Object.getPrototypeOf (или .__proto__):

const obj = {};
console.info(
  obj.__proto__ === Object.prototype,
  Object.getPrototypeOf(obj) === Object.prototype,
);

.prototype.constructor функции — это действительно просто ссылка на функцию.

function foo(){};
console.info(
  foo.prototype.constructor === foo
);

Это не очень полезно, когда у вас уже есть ссылка на конструктор, но это является полезно, когда у вас есть ссылка на экземпляр, но вы не знаете его конструктор - с прототипным наследованием доступ к свойству экземпляра даст вам используемую функцию чтобы построить его:

const bar = (() => {
  function Bar(){}
  const bar = new Bar();
  return bar;
})();

// now Bar is out of scope
// but you can still reference it because you have an instance:
const Bar = bar.constructor;
console.info(Bar);

Чтобы ответить на ваш второй вопрос:

That prototype object has a prototype of its own...

Я думаю, что проще понять эту концепцию, если вы действительно посмотрите на простой пример нескольких уровней прототипа и на то, как это работает на практике:

function ClassA() {
  this.a = 1;
}
ClassA.prototype.getA = function(){
  return this.a;
};

function ClassB() {
  this.b = 2
}
ClassB.prototype = new ClassA();
ClassB.prototype.getB = function(){
  return this.b;
};

var b = new ClassB();
console.info(b.getA());
> 1
console.info(b.getB());
> 2

Теперь вы заметите, что когда мы определяем класс (функцию), мы расширяем (или добавляем) prototype. Но когда мы смотрим на экземпляр класса (b в моем примере), там нет prototype; это называется __proto__, как уже объяснил @CertainPerformance). Итак, взглянув на цепочку прототипов b, вы увидите следующее:

b.__proto__
> ClassA {a: 1, getB: ƒ}
b.__proto__.__proto__
> {getA: ƒ, constructor: ƒ}
b.__proto__.__proto__.__proto__
> {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
b.__proto__.__proto__.__proto__.__proto__
> null

Поэтому, когда вы вводите b.getB(), движок JavaScript сначала просматривает прямые свойства в объекте b и не видит getB. Затем он смотрит на b.__proto__, находит его и готово.

Для b.getA() он делает то же самое, но не находит его в первом прототипе. Итак, он продолжает b.__proto__.__proto__ и находит его там.

То, что вы видите, отличается. Сначала вы смотрите на prototype функции и видите, что внутри нее есть еще одна функция с именем constructor. А так как constructor также является функцией, внутри нее есть prototype. И так далее, навсегда. Но это — это прототип функции-конструктора, НЕТ — часть цепочки прототипов исходной функции/объекта.