That’s the typical case of a so-called “self-referencing”/“self-referential” datatype; the compiler doesn’t give you any support on something like this (i.e. unsafe code is necessary to do something like this). There are some crates out there that can help (so you don’t need to touch any unsafety yourself), e.g. the crate ouroboros.
Note that references refer to memory locations, and moving a value changes its location in memory, so an existing reference would be invalidated. However, a reference derived from another reference might be more stable, e.g. you can derive a &T from a &Box<T>, and when the Box<T> moves, the address for the &T remains stable. E.g. ouroboros addresses this issue this by wrapping every referenced field into an implicit Box, and then it only allows you to access the derived &T references.
No, there isn't. If you move a stack value, its address changes. Putting the value on the heap is the whole point – the implicit, owning indirection means that moving the box doesn't move its heap-allocated contents, only the pointer itself.
Good point, though that's just a small technical detail. In fact, AFAIK current versions of ouroboros do use an AliasableBox type (which contains a raw pointer) instead of ordinary Box for this reason.