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.Receiver/AudioReceiver.cs

@@ -248,20 +248,25 @@ public sealed class AudioReceiver : IDisposable
     /// servicing, scheduler not waking our receive thread, kernel batching). 2026-05-21.</summary>
     public int TakeMaxInterPacketGapMs() => listener.TakeMaxInterPacketGapMs();
 
-    /// <summary>Worst FanOutSource cache-occupancy seen since the last call, expressed in
-    /// milliseconds at the mix rate (48 kHz stereo float). With one active render lane the
-    /// FanOut should drain to ~0 after every consumer Read; sustained non-zero means a
-    /// render lane is holding samples (slow consumer holding back compaction, or the fast
-    /// consumer not draining quickly enough). Zero in WasapiOnly mode (no FanOut). Resets
-    /// on read. Added 2026-05-11 to verify the BothIndependent FanOut path isn't quietly
-    /// inflating latency on either lane.</summary>
-    public int TakeMaxFanOutCacheMs()
-    {
-        // 48000 Hz × 2 ch × 4 bytes/sample = 384,000 bytes/sec.
-        const int MixBytesPerSecond = 48000 * 2 * 4;
-        var bytes = (multiOutput as CompositeRenderBackend)?.TakeMaxFanOutCacheBytes() ?? 0;
-        return bytes * 1000 / MixBytesPerSecond;
-    }
+    /// <summary>Cumulative milliseconds the network receive thread spent inside packet-
+    /// handler work since the last call (drain-on-read pattern). Diag log emits this as
+    /// recvMs per second — a direct read of how busy the network thread is. Item 2 of
+    /// RemSoundefficiency.md. Resets on read.</summary>
+    public double TakeReceiveWorkMs() =>
+        listener.TakeCumulativeOnPacketTicks() * 1000.0 / Stopwatch.Frequency;
+
+    /// <summary>Cumulative milliseconds the audio render threads spent inside
+    /// <see cref="PlayoutEngine.Read"/> / <see cref="PlayoutEngine.ReadForRoute"/>
+    /// (per-session mix + volume + limiter + pack-to-bytes) since the last call. Diag log
+    /// emits this as renderMs per second. Resets on read. 2026-05-22.</summary>
+    public double TakeRenderWorkMs() =>
+        playoutEngine.TakeCumulativeRenderTicks() * 1000.0 / Stopwatch.Frequency;
+
+    // TakeMaxFanOutCacheMs removed 2026-05-23. Originally measured the FanOutSource cache age
+    // between WASAPI and ASIO consumers in BothIndependent mode. The FanOut architecture was
+    // removed in May when each lane got its own filtered PlayoutEngine source — there is no
+    // shared cache to measure any more, so the method always returned 0. Removed alongside
+    // CompositeRenderBackend.TakeMaxFanOutCacheBytes and the fanCacheMs= diag column.
     public string OutputDeviceName => multiOutput.ActiveDeviceSummary;
     public int CurrentBufferMs => playoutEngine.CurrentBufferMs;
     public int TargetLatencyMs => playoutEngine.TargetLatencyMs;
@@ -412,11 +417,9 @@ public sealed class AudioReceiver : IDisposable
     public long TrimDropBytes => playoutEngine.AggregateTrimDropBytes;
     public long DrainDropBytes => playoutEngine.AggregateDrainDropBytes;
     public long TrimFireCount => playoutEngine.AggregateTrimFireCount;
-    /// <summary>Phase-2 drift correction counters: how many single stereo frames have been
-    /// dropped (sender clock faster) or repeated (sender clock slower) to keep the playout
-    /// buffer aligned with target. Each event = 21 µs of audio at 48 kHz, sub-audible.</summary>
-    public long DriftDropFrames => playoutEngine.AggregateDriftDropFrames;
-    public long DriftRepeatFrames => playoutEngine.AggregateDriftRepeatFrames;
+    // DriftDropFrames / DriftRepeatFrames accessors removed 2026-05-23. They aggregated
+    // Phase-2 splice-corrector counters that the Phase-4 fixed-ratio resampler design never
+    // increments. Always-zero. Surfaced two unhelpful diag-log columns that are now gone.
     /// <summary>Cumulative count of FULL-empty playout reads (framesRead == 0) — the audible
     /// underrun events that trigger noise-burst concealment + fade-in. Separated from
     /// <see cref="Underruns"/> (which conflates full and partial short reads) so the diag
@@ -429,9 +432,8 @@ public sealed class AudioReceiver : IDisposable
     /// <summary>Live LP-filtered drift error of the primary active session (stereo frames,
     /// signed). Negative = buffer running below target on average; positive = above.</summary>
     public double FilteredDriftErrorFrames => playoutEngine.PrimaryFilteredDriftErrorFrames;
-    /// <summary>Live drift integrator accumulator of the primary session. Crosses ±1 to fire
-    /// a drop / repeat correction.</summary>
-    public double DriftAccumulator => playoutEngine.PrimaryDriftAccumulator;
+    // DriftAccumulator removed 2026-05-23. Phase-4 fixed-ratio resampler never sets an
+    // integrator value; always returned 0. Removed alongside the driftAcc= diag column.
     /// <summary>Take the worst single-sample step out of the ring buffer (after decode +
     /// SessionPlayout.Write, before resampler) since the last call.</summary>
     public float TakeMaxPostRingReadStep() => playoutEngine.TakeMaxPostRingReadStep();