I’m porting a C data structure to Rust where a struct holds a pointer to a field of another struct. Here’s the C code:

struct Node { struct Node *next; };
struct Tree {
struct Node *start;
struct Node **dangling_arrow;  // Points to a Node's 'next' field
};

int main() {
struct Node node;
struct Tree tree;
tree.dangling_arrow = &node.next;  // Modify later via *dangling_arrow
}

In Rust, I need dangling_arrow to point to a heap-allocated Node's next field. Multiple Tree instances may reference this field. My attempt:

struct Node {
    next: Option<Box<Node>>,
}

struct Tree {
    start: Option<Box<Node>>,
    dangling_arrow: *mut Option<Box<Node>>,  // Raw pointer to Node's 'next'
}

fn main() {
    let mut node = Box::new(Node { next: None });
    let mut tree = Tree {
        start: Some(node),
        dangling_arrow: &mut node.next as *mut _,
    };
}

This compiles but may have undefined behavior since node is moved into tree.start, invalidating dangling_arrow. How can I safely manage this pointer, preferably with minimal overhead?

I’ve tried Rc<RefCell<Node>> but it adds runtime checks. Is there an unsafe approach that ensures lifetime validity?