Это из-за перегруженности термина "прототип" в самом стандарте, протослишком протомного прототипов в прототипном протоязыке.

Zeroglif,
хватит ломать мне мозг.
он и так разрушен радио "Воруй, Убивай" и проектом "Нежное Это"
а тут еще прототипы, до кучи

Так в этом-то видно и дело. Но пока попытаюсь еще задать вопросы, пользуясь своей терминологией. Непонятки там, где стоят ?? :

//var constr = function() {} ; /* или так */ var constr = new Function() /* или так */ function constr() {} 
var constr = new Function() // constr - есть объект(экземпляр) типа(класса) Function ( Function - это не родитель объекта constr , а его тип(класс) ) 
//  - кроме создания объекта-конструктора constr еще выполяется следующее :
//   - создаётся новый объект-прототип (ссылка на который заносится в constr.prototype) ; 
//   - значением свойства constructor этого объекта становится создавший его объект-конструктор (constr.prototype.constructor=constr); 
//   - значением свойства prototype объекта-конструктора становится вновь созданный объект  - А что это за объект ??- непонятно.

var a=new constr()          // a      - есть объект(экземпляр) типа(класса) constr   ( constr   - это не родитель объекта a , а его тип(класс) )
document.write([
// Иерархия объектов пользователя (прикладных объектов)--------- :

a.constructor.prototype===a.__proto__,
a.constructor.prototype===constr.prototype,
a.__proto__===constr.prototype, // родитель объекта a (ссылка на родителя содержится в свойстве prototype конструктора объекта a)

//constr.prototype.constructor, // ==function anonymous() { }  <- конструктор родителя
constr.prototype.constructor.prototype=='[object Object]' , constr.prototype.__proto__ =='[object Object]',
constr.prototype.constructor.prototype===constr.prototype.__proto__ , // FALSE ??

constr.prototype.constructor===constr, // TRUE (значением свойства constructor родителя будет создавший его объект-конструктор constr );

// К слову, также не понятно, почему :
a.__proto__.constructor===a, //FALSE , т.к. а - не есть объект-конструктор ??
constr.prototype.__proto__.__proto__===null,     // TRUE  - вершина
constr.prototype.__proto__===Object.prototype,   // TRUE 

])

Т.е. я пытался, но мне не удалось построить стройную и понятную, где был бы понятен каждый объект в цепи наследования, иерахию объектов от a к родоначальнику Object.prototype, у которого уже нет родителя.

до тех пор, пока вы не переопределите свойство prototype объекта-конструктора, это просто пустой объект типа constr (то есть его конуструктором считается функция constr), с пустым набором свойств
__________________________________________________ ______
несмотря на то что левая и правая часть последнего сравнения являются объектами, сравнение ложно.
потому что это разные объекты

//конструктор свойства prototype конструктора является сам конструктор
constr.prototype.constructor==constr//из этого следует =>
constr.prototype.constructor.prototype==constr.prototype
//такую конструкцию можно дополнять циклично на любой уровень вложенности
//--------------------------------------------------------------
прототипом свойства prototype конструктора является свойство prototype конструктора Object.
constr.prototype.__proto__==Object.prototype
//--------------------------------------------------------------
constr.prototype!=Object.prototype
//зато:
constr.prototype.__proto__==Object.prototype
//то есть прототипом свойства prototype является свойство prototype Object()

__________________________________________________ ______
а мне непонятно с чего вы решили что это должно быть так

a //объект
a.__proto__ //прототип объекта(является экземпляром типа constr)
a.__proto__.constructor //конструктор прототипа
a.__proto__.constructor==a.constructor//у прототипа и у объекта общий конструктор
a.__proto__.constructor==constr//и этот конструктор - функция constr, а не объект a

__________________________________________________ ______
на закуску:

var a=new constr()          // a      - есть объект(экземпляр) типа(класса) constr   ( constr   - это не родитель объекта a , а его тип(класс) )
alert(a.__proto__==constr.prototype)//TRUE
constr.prototype=new constr()
alert(a.__proto__==constr.prototype)//уже FALSE, так как прототип объекта остался тем же, а вот свойство prototype его конструктора уже изменилось

__________________________________________________ ______
По поводу же иерахии напишу так:

var constr = new Function()
var a=new constr()
console.log([
a.__proto__==constr.prototype, //прототип объекта
constr.prototype.__proto__==Object.prototype, //прототип прототипа объекта
Object.prototype.__proto__==null //прототип прототипа прототипа объекта уже не существует
])

это просто объект, как, если бы: new Object(), просто свойство constructor этого нового объекта будет ссылаться на конструктор (constr).

Точнее, не общий конструктор, а один и тот же конструктор, поскольку объект "а" не имеет родного свойства constructor, и оно будет найдено в прототипе (т.е. уже здесь начинается наследование)

Gvozd,
Разные. Общим можно назвать свойство 'constructor' (в плане получения значения).

Оттого, что у объекта-конструктора это вот так :
constr.prototype.constructor===constr
а у объекта-НЕконструктора это НЕтак . короче , заплутал малость, решил , что constr.prototype=constr.__proto__

Т.е. непонятка мешает : отчего же свойство constructor недоступно для объекта, не являющегося конструктором ?

PS. Остальное позже разберу.

Да, чтобы совсем очень терминологически точно, и я должен был написать:

"не общий конструктор, а один и тот же объект, к которому приведёт свойство constructor" (хотя, конечно, это и имелось в виду)

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

вы имеете в виду a.constructor?
вообще-то он доступен:

alert(a.constructor)//зависит от способа создания конструктора
//если var constr = new Function(), то будет анонимная функция
//если function constr(){} , то будет именованая функция constr()
console.log(a.constructor==constr)//TRUE