Static_cast'd значение указателя

Is there a case, when casting a void * to something pointer-interconvertible actually changes the pointer value?

Нет, в стандарте четко указано

If two objects are pointer-interconvertible, then they have the same address

What is the intent of this distinction?

Я думаю, различие заключается не в значении указателя, а в его семантике. Важная часть заключается в том, что вы получаете указатель на объект b (который взаимно перекрывается с указанным исходным объектом). Это более сильная и конкретная гарантия, чем «исходное значение остается неизменным», даже если в этом случае исходное значение также остается неизменным.

Более сильная гарантия: результирующий указатель указывает на реальный объект (а не только на адрес в памяти)

A более конкретная гарантия: этот объект указан: это объект b, который является указателем, взаимозаменяемым с исходным объектом, на который указывает указатель.

Вы можете неправильно понять термин «значение указателя». Термин определен в [basic.compound] / 3:

Every value of pointer type is one of the following:

• a pointer to an object or function (the pointer is said to point to the object or function), or

• a pointer past the end of an object ([expr.add]), or

• the null pointer value ([conv.ptr]) for that type, or

• an invalid pointer value.

A value of a pointer type that is a pointer to or past the end of an object represents the address of the first byte in memory ([intro.memory]) occupied by the object or the first byte in memory after the end of the storage occupied by the object, respectively.

Таким образом, вы можете видеть, что термин «значение указателя» в стандарте - очень абстрактный термин. Даже если два значения указателя представляют один и тот же адрес, они могут иметь разные значения. Пример в cppreference прекрасно демонстрирует концепцию «значения указателя»:

struct S1 { int a; } s1;
struct S2 { int a; private: int b; } s2; // not standard-layout
union U { int a; double b; } u = {0};
int arr[2];
 
int* p1 = reinterpret_cast<int*>(&s1); // value of p1 is "pointer to s1.a" because s1.a
                                       // and s1 are pointer-interconvertible
 
int* p2 = reinterpret_cast<int*>(&s2); // value of p2 is unchanged by reinterpret_cast and
                                       // is "pointer to s2". 
 
int* p3 = reinterpret_cast<int*>(&u);  // value of p3 is "pointer to u.a": u.a and u are
                                       // pointer-interconvertible
 
double* p4 = reinterpret_cast<double*>(p3); // value of p4 is "pointer to u.b": u.a and u.b
                                            // are pointer-interconvertible because both
                                            // are pointer-interconvertible with u
 
int* p5 = reinterpret_cast<int*>(&arr); // value of p5 is unchanged by reinterpret_cast and
                                        // is "pointer to arr"