feat(M2): UDP voice/media plane -- SFU relay, Opus, AEAD, jitter buffer

Adds the full voice pipeline: 14-byte binary frame header, ChaCha20-Poly1305
AEAD keyed from the TLS exporter, libopus encode/decode with FEC/PLC/DTX,
an adaptive per-ssrc jitter buffer, a miniaudio capture/playback engine, an
APM passthrough stub, and the UdpBinding/StreamAnnounce signaling chain
wired through ConnSession/SessionRegistry into a new server-side SFU
(MediaRelay) that decrypts and re-encrypts frames per channel member.

Exit criterion verified: test_m2_voice — two headless clients relay 50
encrypted Opus frames through the server; ctest --preset m1-dev is 9/9
green. Also corrects protocol.md's UdpBinding diagram, which described the
UDP-side binding packet as AEAD-sealed when it is in fact a plaintext
bootstrap frame (separate from the TCP/TLS UdpBinding ack).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

server/src/session_registry.h

@@ -1,7 +1,8 @@
 /*
  * server/session_registry.h — In-memory session, channel, and user registry.
  *
- * Tracks all authenticated sessions, the channel tree, and user<→>channel assignments.
+ * Tracks all authenticated sessions, the channel tree, user<→>channel assignments,
+ * UDP endpoint bindings (M2), and SSRC<→>session mappings (M2).
  * Protected by a shared_mutex (many readers, few writers). All methods are thread-safe.
  */
 #ifndef VOICECAT_SERVER_SESSION_REGISTRY_H
@@ -9,6 +10,8 @@
 
 #ifdef VOICECAT_HAS_NET
 
+#include <array>
+#include <atomic>
 #include <cstdint>
 #include <memory>
 #include <shared_mutex>
@@ -16,6 +19,9 @@
 #include <unordered_map>
 #include <vector>
 
+#define ASIO_STANDALONE 1
+#include <asio.hpp>
+
 #include "proto/voicecat.pb.h"
 
 namespace voicecat::server {
@@ -31,6 +37,14 @@ struct UserEntry {
     uint64_t session_id{};
 };
 
+// Hashes asio::ip::udp::endpoint by "addr:port" string.
+struct UdpEndpointHash {
+    size_t operator()(const asio::ip::udp::endpoint& ep) const {
+        std::string key = ep.address().to_string() + ':' + std::to_string(ep.port());
+        return std::hash<std::string>{}(key);
+    }
+};
+
 class SessionRegistry {
    public:
     SessionRegistry() = default;
@@ -58,14 +72,36 @@ class SessionRegistry {
     std::vector<voicecat::v1::User>    user_snapshot() const;
 
     // Resolve target sessions for a text message relay.
-    // TEXT_CHANNEL: all users in that channel (except sender's session).
-    // TEXT_PRIVATE: the session for that user_id.
     std::vector<std::shared_ptr<ConnSession>> resolve_text_targets(
         uint64_t sender_session_id, voicecat::v1::TextScope scope, uint32_t target_id) const;
 
     // Broadcast an envelope to all sessions except the excluded one.
     void broadcast(const voicecat::v1::Envelope& env, uint64_t exclude_session_id = 0) const;
 
+    // ── M2: UDP / media ──────────────────────────────────────────────────────
+
+    // Register a session's UDP token (called at auth success).
+    void register_udp_token(const std::array<uint8_t, 16>& token, uint64_t session_id);
+
+    // Locate a session by its UDP binding token (called by MediaRelay on UDP_BINDING).
+    std::shared_ptr<ConnSession> find_by_udp_token(const std::array<uint8_t, 16>& token) const;
+
+    // Associate a UDP endpoint with a session (called by MediaRelay after token verification).
+    void register_udp_endpoint(asio::ip::udp::endpoint ep, uint64_t session_id);
+
+    // Locate the session that owns a UDP sender endpoint (called per incoming voice packet).
+    std::shared_ptr<ConnSession> find_by_udp_endpoint(const asio::ip::udp::endpoint& ep) const;
+
+    // Assign an SSRC for a new stream. Returns the assigned SSRC.
+    uint32_t assign_ssrc(uint64_t session_id);
+
+    // Get all sessions in a channel except the one excluded (for SFU relay).
+    std::vector<std::shared_ptr<ConnSession>> find_channel_sessions(
+        uint32_t channel_id, uint64_t exclude_session_id = 0) const;
+
+    // Return the channel_id of a user (0 if not found).
+    uint32_t user_channel(uint32_t user_id) const;
+
    private:
     mutable std::shared_mutex mu_;
 
@@ -76,6 +112,24 @@ class SessionRegistry {
     std::unordered_map<uint64_t, std::weak_ptr<ConnSession>> sessions_;
     std::unordered_map<uint32_t, UserEntry>                   users_;
     std::unordered_map<uint32_t, ChannelEntry>                channels_;
+
+    // M2: token → session_id (populated at auth, cleared on disconnect)
+    struct TokenHash {
+        size_t operator()(const std::array<uint8_t, 16>& t) const {
+            // FNV-1a over 16 bytes
+            size_t h = 14695981039346656037ULL;
+            for (auto b : t) { h ^= b; h *= 1099511628211ULL; }
+            return h;
+        }
+    };
+    std::unordered_map<std::array<uint8_t, 16>, uint64_t, TokenHash> udp_tokens_;
+
+    // M2: UDP endpoint → session_id (populated after UDP binding packet arrives)
+    std::unordered_map<asio::ip::udp::endpoint, uint64_t, UdpEndpointHash> udp_endpoints_;
+
+    // M2: ssrc → session_id (populated when StreamAnnounce is processed)
+    std::unordered_map<uint32_t, uint64_t> ssrc_to_session_;
+    std::atomic<uint32_t> next_ssrc_{1};
 };
 
 }  // namespace voicecat::server