Почему С++ не разрешает преобразование неконстантного в константное в copy ctor?

Вы не пытаетесь сделать неконстантное преобразование в константное. Вы пытаетесь вызвать два метода, которые не являются константами и ссылкой на константу (вызовы prev и value). Этот тип операции строго запрещен константной семантикой.

Вместо этого вы могли бы использовать поля prev_ и value_ напрямую. Поскольку это член того же типа, вы можете получить доступ к приватным, которые будут доступны в объекте const.

Я думал, что С++ допускает преобразование неконстантных в константные параметры функции, например:

Вы пытаетесь сделать прямо противоположное: от константы к неконстанте. При вызове неконстантной функции-члена компилятор свяжет выражение (которое представляет собой Node const с Node& для привязки указателя this). Таким образом, он отбросит const - не разрешено, потому что он вызовет неконстантную функцию для константного объекта.

/* class Foo */ {
   Foo(int bar);
}

/* Foo:: */ Foo(const int bar)
{
   //lala
}

Ну этот код совсем другое дело. Он объявляет функцию (конструктор) два раза, с той лишь разницей, что один раз параметр константный, а другой раз нет. Тип функции в обоих случаях один и тот же, поэтому они не конфликтуют (параметр const будет влиять только на тело функции локально — для вызывающей стороны это не будет иметь никакого значения). Кроме того, этот код не содержит никаких вызовов (при условии, что первый блок находится внутри какой-то функции).

Если вы задаетесь вопросом: если две вышеприведенные версии идентичны, почему нижеприведенная не такая? Тогда это связано с тем, что ниже содержится еще один уровень косвенности: ниже сама ссылка (верхний уровень) не является константой (вы не можете напрямую поставить const на саму ссылку), а тип ссылка является константой. В настоящее время const не игнорируется при определении типа функции.

/* class Foo */ {
   Foo(int &bar);
}

// different thing, won't work!
/* Foo:: */ Foo(const int &bar)
{
   //lala
}

Вы правы - const означает, что вы обещаете ничего не менять. Компилятор заставляет вас сдержать свое обещание, не позволяя вам вызывать методы для этого объекта, которые сами по себе не обещают ничего не менять.

В объявлении конструктора Node(Node const& other) аргумент other объявляется const. Это означает, что вы можете вызывать только const метода.

Вы вызываете other.prev() и other.value() из конструктора, оба из которых не являются методами const, поэтому компилятор жалуется.

Как уже упоминалось, вы вызываете неконстантные методы для константного объекта, который компилятор не разрешает.

Простое решение для этого - просто пометить ваши функции-получатели как const:

Node* prev() const { return prev_; }
int value()  const { return value_; }

поскольку они не изменяют объект; теперь их можно вызывать с помощью константного объекта. На самом деле это, вероятно, следует сделать в любом случае, чтобы пользователи класса могли вызывать эти геттеры с константными объектами.

Однако у вас есть еще одна потенциальная проблема, если ваш копировщик выглядит так:

Node(Node const& other) : prev_(other.prev()), value_(other.value()) { }

копия и оригинал будут указывать на один и тот же объект Node в своем элементе prev_. В зависимости от семантики класса это может быть нормально, но это может быть проблема владения или другое логическое несоответствие.