mbproxy: add in-flight read coalescing (Phase 10)

When two or more upstream clients send the same FC03/FC04 read while a
matching request is already in flight on the same PLC's multiplexed
backend socket, attach the late arrivals to the existing InFlightRequest
.InterestedParties list instead of opening a second backend round-trip.
The single backend response fans out to every attached party with each
party's original MBAP TxId restored individually. Zero post-response
staleness — coalescing operates entirely within the in-flight window
(microseconds to ~10 ms typical); the proxy is NOT a cache layer.

Headline mechanism:

- New record struct CoalescingKey(UnitId, Fc, StartAddress, Qty) keys
  the per-PLC InFlightByKeyMap. FC03 and FC04 are separate Modbus
  tables and never share a key; different unit IDs never coalesce;
  writes (FC06/FC16) bypass the coalescing path entirely.
- InFlightByKeyMap uses a simple lock around a Dictionary; atomic
  TryAttachOrCreate either appends a new party to the in-flight
  request's mutable List<InterestedParty> or invokes a factory to
  build a fresh entry. Per-entry MaxParties cap (default 32) bounds
  fan-out cost; past the cap, the next arrival opens a new entry.
- PlcMultiplexer.OnUpstreamFrameAsync takes the coalescing path for
  FC03/FC04 when Mbproxy.Resilience.ReadCoalescing.Enabled. The
  factory closure does the Phase-9 work (allocate TxId, add to
  CorrelationMap); the channel send happens AFTER returning from
  TryAttachOrCreate so the map lock is not held across the async send.
- Response fan-out in RunBackendReaderAsync removes the entry from
  InFlightByKeyMap before iterating InterestedParties, ensuring no
  concurrent attach can mutate the list during iteration.
- Cascade + watchdog paths also drain the key map so a stale entry
  cannot outlive its backend round-trip.

Counter accounting balance (per snapshot): CoalescedHitCount +
CoalescedMissCount equals total FC03 + FC04 requests since startup.
Even with coalescing disabled, every read still bumps Miss so dashboard
math stays balanced.

New surface (additive only):
- src/Mbproxy/Proxy/Multiplexing/CoalescingKey.cs
- src/Mbproxy/Proxy/Multiplexing/InFlightByKeyMap.cs
- src/Mbproxy/Proxy/Multiplexing/CoalescingLogEvents.cs
- ReadCoalescingOptions on ResilienceOptions
- CoalescedHitCount / CoalescedMissCount /
  CoalescedResponseToDeadUpstream counters surfaced on /status.json
  per PLC and as a compact "Coal" cell on the HTML status page.

Phase 9 test patch: TwoUpstreams_ProxyTxIds_AreDistinct_OnTheWire
previously read the same register from both clients (which now
coalesces). Patched to read two different addresses so the test still
proves distinct backend TxIds without violating the coalescing
contract.

Tests added: 24 new (19 unit + 5 E2E):
- CoalescingKeyTests (5)
- InFlightByKeyMapTests (6, includes concurrent stress)
- ReadCoalescingTests (8, stub-backend with deterministic delay)
- ReadCoalescingE2ETests (5, pymodbus simulator; coalescing-active
  during overlap is proven against the stub, not the sim, due to
  pymodbus 3.13's known concurrent-frame bug)

Total: 325 tests passing (282 unit + 43 E2E).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

mbproxy/src/Mbproxy/Proxy/ProxyCounters.cs

@@ -79,7 +79,25 @@ public sealed record CounterSnapshot(
     /// (frames queued, not yet on the wire). A sustained non-zero value indicates the
     /// backend is slower than upstream demand. Phase 9.
     /// </summary>
-    long BackendQueueDepth);
+    long BackendQueueDepth,
+    /// <summary>
+    /// Phase 10 — cumulative count of FC03/FC04 requests that attached to an already-in-flight
+    /// peer instead of opening a fresh backend round-trip. <c>CoalescedHitCount + CoalescedMissCount</c>
+    /// equals total FC03/FC04 requests seen by the multiplexer.
+    /// </summary>
+    long CoalescedHitCount,
+    /// <summary>
+    /// Phase 10 — cumulative count of FC03/FC04 requests that opened a fresh in-flight entry
+    /// (no matching peer was in flight, or the matching peer had reached its <c>MaxParties</c>
+    /// cap). With <c>ReadCoalescing.Enabled = false</c>, every FC03/FC04 request becomes a miss.
+    /// </summary>
+    long CoalescedMissCount,
+    /// <summary>
+    /// Phase 10 — count of coalesced response fan-outs that were skipped because the
+    /// attached upstream pipe had already disconnected. A spike is a churn indicator; the
+    /// metric itself is informational (Tier 2 in <c>docs/kpi.md</c>).
+    /// </summary>
+    long CoalescedResponseToDeadUpstream);
 
 /// <summary>
 /// Thread-safe per-PLC counters backed by <see cref="System.Threading.Interlocked"/> longs.
@@ -114,6 +132,11 @@ internal sealed class ProxyCounters
     private long _maxInFlight;
     private long _backendDisconnectCascades;
 
+    // Phase 10 — coalescing counters. Hit + Miss = total FC03/FC04 requests.
+    private long _coalescedHitCount;
+    private long _coalescedMissCount;
+    private long _coalescedResponseToDeadUpstream;
+
     // Phase 9: live state pulled from the multiplexer's allocator/map/queue on each
     // snapshot. The multiplexer registers a single provider via SetMultiplexProvider.
     // We use a volatile reference for lock-free read on the snapshot path.
@@ -201,6 +224,26 @@ internal sealed class ProxyCounters
     public void AddDisconnectCascades(int n)
         => Interlocked.Add(ref _backendDisconnectCascades, n);
 
+    /// <summary>
+    /// Phase 10 — records one FC03/FC04 request that attached to an already-in-flight peer.
+    /// </summary>
+    public void IncrementCoalescedHit()
+        => Interlocked.Increment(ref _coalescedHitCount);
+
+    /// <summary>
+    /// Phase 10 — records one FC03/FC04 request that opened a fresh in-flight entry
+    /// (no matching peer was in flight, or the matching peer had reached MaxParties).
+    /// </summary>
+    public void IncrementCoalescedMiss()
+        => Interlocked.Increment(ref _coalescedMissCount);
+
+    /// <summary>
+    /// Phase 10 — records one coalesced response fan-out that was skipped because the
+    /// attached upstream pipe had already disconnected. Informational only.
+    /// </summary>
+    public void IncrementCoalescedResponseToDeadUpstream()
+        => Interlocked.Increment(ref _coalescedResponseToDeadUpstream);
+
     /// <summary>
     /// CAS-updates the peak in-flight high-water mark. Called on every successful
     /// allocation by the multiplexer. Phase 9.
@@ -311,7 +354,10 @@ internal sealed class ProxyCounters
             MaxInFlight:               Interlocked.Read(ref _maxInFlight),
             TxIdWraps:                 txWraps,
             BackendDisconnectCascades: Interlocked.Read(ref _backendDisconnectCascades),
-            BackendQueueDepth:         queueDepth);
+            BackendQueueDepth:         queueDepth,
+            CoalescedHitCount:         Interlocked.Read(ref _coalescedHitCount),
+            CoalescedMissCount:        Interlocked.Read(ref _coalescedMissCount),
+            CoalescedResponseToDeadUpstream: Interlocked.Read(ref _coalescedResponseToDeadUpstream));
     }
 }