Refactor node/handlers.rs and node/tests.rs into subdirectories

Split handlers.rs (986 lines) into handlers/ with 5 subfiles organized
by responsibility: rx_loop, encrypted, handshake, dispatch, timeout.

Split tests.rs (2350 lines) into tests/ with 4 subfiles: unit tests,
handshake integration, spanning tree convergence, and bloom filter tests.
Shared test helpers extracted to tests/mod.rs.

Visibility adjusted from pub(super) to pub(in crate::node) for handler
methods now two levels deep. Unused imports cleaned up in node/mod.rs.

All 316 tests pass, zero warnings.

src/node/tests/mod.rs

@@ -0,0 +1,67 @@
+use super::*;
+use crate::index::SessionIndex;
+use crate::transport::{LinkDirection, TransportAddr};
+use std::time::Duration;
+
+mod bloom;
+mod handshake;
+mod spanning_tree;
+mod unit;
+
+pub(super) fn make_node() -> Node {
+    let config = Config::new();
+    Node::new(config).unwrap()
+}
+
+#[allow(dead_code)]
+pub(super) fn make_node_addr(val: u8) -> NodeAddr {
+    let mut bytes = [0u8; 16];
+    bytes[0] = val;
+    NodeAddr::from_bytes(bytes)
+}
+
+pub(super) fn make_peer_identity() -> PeerIdentity {
+    let identity = Identity::generate();
+    PeerIdentity::from_pubkey(identity.pubkey())
+}
+
+/// Create a PeerConnection with a completed Noise IK handshake.
+///
+/// Returns (connection, peer_identity) where the connection is outbound,
+/// in Complete state, with session, indices, and transport info set.
+pub(super) fn make_completed_connection(
+    node: &mut Node,
+    link_id: LinkId,
+    transport_id: TransportId,
+    current_time_ms: u64,
+) -> (PeerConnection, PeerIdentity) {
+    let peer_identity_full = Identity::generate();
+    // Must use from_pubkey_full to preserve parity for ECDH
+    let peer_identity = PeerIdentity::from_pubkey_full(peer_identity_full.pubkey_full());
+
+    // Create outbound connection
+    let mut conn = PeerConnection::outbound(link_id, peer_identity.clone(), current_time_ms);
+
+    // Run initiator side of handshake
+    let our_keypair = node.identity.keypair();
+    let msg1 = conn.start_handshake(our_keypair, current_time_ms).unwrap();
+
+    // Run responder side to generate msg2
+    let mut resp_conn = PeerConnection::inbound(LinkId::new(999), current_time_ms);
+    let peer_keypair = peer_identity_full.keypair();
+    let msg2 = resp_conn
+        .receive_handshake_init(peer_keypair, &msg1, current_time_ms)
+        .unwrap();
+
+    // Complete initiator handshake
+    conn.complete_handshake(&msg2, current_time_ms).unwrap();
+
+    // Set indices and transport info
+    let our_index = node.index_allocator.allocate().unwrap();
+    conn.set_our_index(our_index);
+    conn.set_their_index(SessionIndex::new(42));
+    conn.set_transport_id(transport_id);
+    conn.set_source_addr(TransportAddr::from_string("127.0.0.1:5000"));
+
+    (conn, peer_identity)
+}