Fix all ThreadSanitizer-reported races in the node lifecycle (8 reports -> 0)

Found by running two nodes under -fsanitize=thread through connect -> mine -> broadcast -> clean
exit. None are in consensus code; all are connection setup/teardown.

Stop flags were plain or volatile ints written by one thread and read as a loop condition by
another. volatile stops the compiler hoisting the load but provides neither atomicity nor
ordering, which on arm64 is a real visibility gap, not just a sanitizer complaint. Now _Atomic:
 - net_node_t.maintenanceRunning  (Node_Destroy vs Node_MaintenanceThread)
 - tcp_server_t.isRunning         (TcpServer_Stop vs both accept threads) -- was a bare int, so
                                   the accept loop could legally be hoisted and never see the stop
 - udp_node_t.isRunning           (UdpNode_Stop vs the recv and retry threads)

TcpServer_Stop had a use-after-free, not merely a race: it took clientsMutex only long enough to
read the array pointer, then walked the slots unlocked. An exiting client thread clears its own
slot under that mutex and immediately destroys and frees the connection, so Stop could
RequestClose and pthread_join a freed pointer on any shutdown with an active peer.
 - Stop now requests the close and copies each pthread_t under the mutex, then joins from the
   copied handles, so the connection is never dereferenced outside the lock
 - the client thread's TcpConnection_Destroy/free moved inside the same critical section, which
   closes the window entirely

Client threads that disconnected normally were never joined and leaked their thread resources:
Stop only joins clients still present in the array, and a normal exit removes itself first. Stop
now claims each slot as it copies the handle, so the client thread can tell who owns its join --
it detaches itself if it successfully removed its own slot, and stays joinable if Stop already
claimed it. Both decisions happen under clientsMutex so the cases cannot interleave.

Node_Destroy cleared outbound slots with no lock (via TcpClient_Disconnect) while live inbound
client threads read the same field correctly under outboundLock in Node_HasLiveConnectionTo. The
lock cannot just be held across the destroy, because that path joins an io thread whose
on_disconnect callback takes outboundLock itself. Reworked to detach the connections from their
slots under the lock and tear them down outside it -- the pattern Node_ReapDeadOutbound already
uses in this file. This one only surfaced once the other five were fixed.

Verified: TSan clean over the same run; nodes still converge (height 25, identical tip); shallow
fork still adopts, depth-8 fork still defers on the reorg penalty, and the forced-orphan
regression still reaches full height with zero coinbase rejections.

include/nets/net_node.h

@@ -25,6 +25,7 @@ typedef struct node_discovery node_discovery_t;
 #include <block/block.h>
 #include <block/chain.h>
 #include <block/transaction.h>
+#include <stdatomic.h>
 
 typedef struct {
     tcp_server_t* server;
@@ -42,7 +43,10 @@ typedef struct {
     void* callbackUser;
     // Maintenance thread for periodic tasks (orphan attach, pruning, metrics)
     pthread_t maintenanceThread;
-    volatile int maintenanceRunning;
+    // Cross-thread stop flag: written by Node_Destroy on the main thread, read by the maintenance
+    // thread's loop condition. `volatile` stops the compiler hoisting the load but provides neither
+    // atomicity nor ordering, so this has to be a real atomic (and TSan rightly flagged it).
+    _Atomic int maintenanceRunning;
     int maintenanceIntervalMs;
     // UDP ping/pong daemon (latency oracle) and peer discovery state
     udp_node_t* udpNode;