feat: add delivery sequence numbers + major server/client refactor

Delivery sequence numbers (MLS epoch ordering fix):
- schemas/node.capnp: add Envelope{seq,data} struct; enqueue returns seq:UInt64;
  fetch/fetchWait return List(Envelope) instead of List(Data)
- storage.rs: Store trait enqueue returns u64; fetch/fetch_limited return
  Vec<(u64, Vec<u8>)>; FileBackedStore gains QueueMapV3 with per-inbox seq
  counters and V2→V3 on-disk migration
- migrations/002_add_seq.sql: seq column, delivery_seq_counters table, index
- sql_store.rs: atomic UPSERT counter via RETURNING, ORDER BY seq, SCHEMA_VERSION→3
- node_service/delivery.rs: builds Envelope list; returns seq from enqueue
- client/rpc.rs: enqueue→u64, fetch_all/fetch_wait→Vec<(u64,Vec<u8>)>
- client/commands.rs: sort-by-seq before MLS processing; retry loop in cmd_recv
  and receive_pending_plaintexts for correct epoch ordering

Server refactor:
- Split monolithic main.rs into node_service/{mod,delivery,auth_ops,key_ops,p2p_ops}
- Add auth.rs (token validation, rate limiting), config.rs, metrics.rs, tls.rs
- Add SQL migrations runner (001_initial.sql, 002_add_seq.sql)
- OPAQUE PAKE login/registration, sealed-sender mode, queue depth limit (1000)

Client refactor:
- Split lib.rs into client/{commands,rpc,state,retry,hex,mod}
- Add cmd_whoami, cmd_health, cmd_check_key, cmd_ping subcommands
- Add cmd_register_user, cmd_login (OPAQUE), cmd_refresh_keypackage
- Hybrid PQ envelope (X25519 + ML-KEM-768) on all send/recv paths
- E2E test suite expanded

Other:
- quicnprotochat-gui: Tauri 2 desktop GUI skeleton (backend + HTML UI)
- quicnprotochat-p2p: iroh-based P2P transport stub
- quicnprotochat-core: app_message, hybrid_crypto modules; GroupMember API updates
- .github/workflows/size-lint.yml: binary size regression check
- docs: protocol comparison, roadmap updates, fully-operational checklist

crates/quicnprotochat-p2p/src/lib.rs

@@ -161,29 +161,26 @@ mod tests {
 
     #[tokio::test]
     async fn p2p_round_trip() {
-        let alice = local_node().await;
-        let bob = local_node().await;
+        let sender = local_node().await;
+        let receiver = local_node().await;
 
-        let bob_addr = bob.endpoint_addr();
-        let alice_id = alice.node_id();
-        let payload = b"hello from alice via P2P";
+        let receiver_addr = receiver.endpoint_addr();
+        let sender_id = sender.node_id();
+        let payload = b"hello via P2P";
 
-        // Spawn Bob's receiver.
-        let bob_handle = tokio::spawn(async move {
-            let msg = bob.recv().await.unwrap();
+        let recv_handle = tokio::spawn(async move {
+            let msg = receiver.recv().await.unwrap();
             assert_eq!(msg.payload, payload.to_vec());
-            assert_eq!(msg.sender, alice_id);
+            assert_eq!(msg.sender, sender_id);
         });
 
-        // Give Bob a moment to start accepting.
         tokio::time::sleep(std::time::Duration::from_millis(200)).await;
 
-        alice.send(bob_addr, payload).await.unwrap();
+        sender.send(receiver_addr, payload).await.unwrap();
 
-        // Wait for Bob to finish reading before closing.
-        bob_handle.await.unwrap();
+        recv_handle.await.unwrap();
 
         tokio::time::sleep(std::time::Duration::from_millis(100)).await;
-        alice.close().await;
+        sender.close().await;
     }
 }