node: make the shared context the sole store of immutable state

Remove the duplicated immutable fields (config, identity, startup_epoch,
started_at, is_leaf_only, max_connections/peers/links) from the Node
struct so the Arc<NodeContext> bundle is the single source of truth.
Previously Node owned these fields and a parallel context copy, kept in
lockstep by rebuild_context() at every mutation site — pure overhead that
existed only because of the duplication.

- Replace rebuild_context() with replace_context(): a clone-edit-swap of
  the whole Arc. The per-instance context stays immutable; mutation swaps
  the Arc. This is the sole runtime mutation path (constructors, leaf_only,
  update_peers).
- Add Copy-returning accessors startup_epoch() and max_connections()/
  max_peers()/max_links(); migrate the remaining direct field readers onto
  the accessors. node_addr()/npub()/Debug now read identity/is_leaf_only
  from the context.
- update_peers reads the pre-update peer set from the live context Arc
  before building a fresh Config + context and swapping — preserving the
  read-before-write ordering its mutation-window test depends on.
- Remove the test-only set_max_* setters; tests set the limits on Config at
  construction instead (new make_node_with_max_peers/links helpers).
- Add a ci-local guard that fails if the Node struct re-declares a bundled
  field, so the single-store invariant can't silently regress.

cargo test --lib 1291/0; clippy -D warnings and release build clean.

src/node/tests/bootstrap.rs

@@ -62,9 +62,9 @@ async fn test_adopted_udp_traversal_completes_handshake() {
     }
 
     let peer_a_node_addr =
-        *PeerIdentity::from_pubkey_full(node_a.identity.pubkey_full()).node_addr();
+        *PeerIdentity::from_pubkey_full(node_a.identity().pubkey_full()).node_addr();
     let peer_b_node_addr =
-        *PeerIdentity::from_pubkey_full(node_b.identity.pubkey_full()).node_addr();
+        *PeerIdentity::from_pubkey_full(node_b.identity().pubkey_full()).node_addr();
 
     assert_eq!(
         node_a.peer_count(),
@@ -223,7 +223,7 @@ async fn test_third_peer_can_handshake_via_adopted_transport_socket() {
     assert_eq!(pkt_at_b.data[0] & 0x0f, PHASE_MSG2);
     node_b.handle_msg2(pkt_at_b).await;
 
-    let node_a_addr = *PeerIdentity::from_pubkey_full(node_a.identity.pubkey_full()).node_addr();
+    let node_a_addr = *PeerIdentity::from_pubkey_full(node_a.identity().pubkey_full()).node_addr();
     assert!(
         node_b.get_peer(&node_a_addr).is_some(),
         "node_b should first be connected to node_a via adopted transport"
@@ -237,7 +237,7 @@ async fn test_third_peer_can_handshake_via_adopted_transport_socket() {
         .transports
         .insert(transport_id_c, TransportHandle::Udp(transport_c));
 
-    let peer_b_identity = PeerIdentity::from_pubkey_full(node_b.identity.pubkey_full());
+    let peer_b_identity = PeerIdentity::from_pubkey_full(node_b.identity().pubkey_full());
     let adopted_addr = TransportAddr::from_string(&handoff_result.local_addr.to_string());
     node_c
         .initiate_connection(transport_id_c, adopted_addr, peer_b_identity)
@@ -273,7 +273,7 @@ async fn test_third_peer_can_handshake_via_adopted_transport_socket() {
     };
     node_c.handle_msg2(pkt_at_c).await;
 
-    let node_c_addr = *PeerIdentity::from_pubkey_full(node_c.identity.pubkey_full()).node_addr();
+    let node_c_addr = *PeerIdentity::from_pubkey_full(node_c.identity().pubkey_full()).node_addr();
     assert!(
         node_b.get_peer(&node_c_addr).is_some(),
         "node_b should promote node_c when node_c handshakes via adopted socket"