Bump to v2.2.0: Opus native binding, efficiency tidy-up, diag self-meter

Single biggest change: added the Concentus.Native NuGet package. Concentus
2.0+ auto-detects native libopus at runtime and routes encode calls
through it; encoder state lives on the C side and is reused across calls
rather than `new`ing ~15 working buffers per call (Concentus issue #22,
open since 2018). Measured on the desktop test at 15:36:55 — Opus 10 ms
allocation rate dropped from 4,625 KB/s to 108 KB/s, a 97.7% reduction.
Process CPU dropped from 4.7% to 1.6% in the same config. Audio is bit-
for-bit identical (it's literally the same encoder, just better
packaged). `OpusEncoderState.cs` itself unchanged on the call site.

Diagnostic / measurement layer (gated on Enable-logs, zero cost when off):
* ProcessSelfMeter: CPU%, managed heap MB, working set MB, allocation
  rate per second, GC counts per generation
* Per-thread work-time counters: captureMs / sendMs / recvMs / renderMs
  expressed as milliseconds of CPU consumed by each audio thread per
  second
* Inter-packet arrival gap measured at the user-space UDP socket
  (rxNetGapMs) — pinpoints whether arrival jitter is in the network or
  our own dispatch path

Small efficiency wins (each one was small but cumulative):
* deviceRefreshTimer interval 1s -> 3s (item 4)
* WaitHandle array allocations eliminated in MixingEngine.MixLoop and
  MultiOutputPlayout.ProduceLoop (item 6)
* MultiOutputPlayout caches its output-buffer snapshot and only rebuilds
  on SetOutputDevices, instead of rebuilding every 10 ms (item 7)
* HeartbeatService reuses an outbound ping byte[] instead of allocating
  per send (item 14)
* PeerDiscoveryService caches broadcast addresses and invalidates on
  Windows' NetworkChange event instead of walking all NICs every 1.5 s
  (item 16)

Legacy / dead-code removal:
* KeepAlive packet's implementation (struct, enums, writer, reader, size
  constant) — all dead since HeartbeatService landed 2026-05-06. Kept
  the RemPacketType.KeepAlive enum value and silent-drop dispatch for
  wire compat with any pre-2026-05-06 build still in the wild (item 30)
* driftDropFramesTotal / driftRepeatFramesTotal fields and accessors —
  Phase-2 splice corrector relics, never incremented since Phase-4
  resampler design landed; backed five always-zero diag log columns
  (items 34 + 35)
* DriftAccumulator (always returned 0) — same shape, removed alongside
  the driftAcc= column (item 35)
* TakeMaxFanOutCacheBytes / Ms + fanCacheMs column — FanOutSource was
  retired in May (item 36)

Project documentation:
* RemSoundefficiency.md added as the canonical record of the efficiency
  analysis, every item's status, and the measured wins from this round
* Honest item-by-item review of the original 50-item list — several
  items I had sized optimistically in the original analysis turned out
  to be already-done (item 20), already-optimal (item 22), or below
  the meter floor (items 9, 15, 17, 25). Recorded so future passes
  don't re-investigate.

Wire format and audio pipeline unchanged from v1.5 onward — v1.5 through
v2.2 peers interoperate.

src/RemSound.Core/HeartbeatService.cs

@@ -63,6 +63,12 @@ public sealed class HeartbeatService : IDisposable
     private CancellationTokenSource? cts;
     private Task? sendTask;
     private uint sequence;
+    // Reusable outbound packet buffer for the once-per-second ping fan-out. Pre-2026-05-23
+    // SendPings did `var bytes = packet.ToArray()` on every call (a 21-byte allocation +
+    // GC header). Trivial in absolute terms — ~3 small allocations/sec/peer — but the
+    // SendPings thread has only one writer so a single reused array is straightforward and
+    // makes the pattern explicit. Item 14 of RemSoundefficiency.md.
+    private readonly byte[] outboundPingBuffer = new byte[RemPacket.HeaderSize + RemPacket.HeartbeatPayloadSize];
 
     /// <summary>
     /// Outbound transport for heartbeat packets. REQUIRED — without it Start() succeeds but
@@ -253,20 +259,22 @@ public sealed class HeartbeatService : IDisposable
             foreach (var p in targets) p.FirstPingSentUtc ??= nowUtc;
         }
 
-        // Build packet. streamId is fixed at 0xFFFF for heartbeats so it's distinguishable
-        // in any future stream-aware filter; sequence increments locally per send.
-        Span<byte> packet = stackalloc byte[RemPacket.HeaderSize + RemPacket.HeartbeatPayloadSize];
+        // Build packet directly into the reusable outboundPingBuffer instead of stack-
+        // allocating + ToArray(). Same wire format, no per-call allocation. SendPings runs
+        // exclusively on the timer task — single writer — so no lock needed around the
+        // reuse. streamId is fixed at 0xFFFF for heartbeats so it's distinguishable in any
+        // future stream-aware filter; sequence increments locally per send.
         var seq = Interlocked.Increment(ref sequence);
         var tickMs = monotonic.ElapsedMilliseconds;
-        RemPacket.WriteHeader(packet, RemPacketType.Heartbeat, 0xFFFF, seq);
-        RemPacket.WriteHeartbeatPayload(packet[RemPacket.HeaderSize..], HeartbeatKind.Ping, tickMs);
-        var bytes = packet.ToArray();
+        var packetSpan = outboundPingBuffer.AsSpan();
+        RemPacket.WriteHeader(packetSpan, RemPacketType.Heartbeat, 0xFFFF, seq);
+        RemPacket.WriteHeartbeatPayload(packetSpan[RemPacket.HeaderSize..], HeartbeatKind.Ping, tickMs);
 
         foreach (var p in targets)
         {
             try
             {
-                var ok = transport(bytes, bytes.Length, p.AudioEndpoint);
+                var ok = transport(outboundPingBuffer, outboundPingBuffer.Length, p.AudioEndpoint);
                 onDiagnostic?.Invoke($"send seq={seq} to={p.AudioEndpoint} {(ok ? "ok" : "FAILED")}");
             }
             catch (Exception ex)