fix(GWC-26): attach the alarm monitor's lease before SubscribeAlarms

RunMonitorAsync issued SubscribeAlarms and the first reconcile before the
internal distributor subscriber was attached (via ISessionManager
.ReadAlarmEventsAsync). The pump has been running since MarkReady started the
dashboard mirror and only fans to subscribers registered at fan-out time, so
every transition raised in that two-round-trip window bypassed the alarm feed —
and a missed Acknowledge was never repaired, because ApplyReconcile broadcast
presence deltas only.

- The monitor now takes the internal lease directly from its session BEFORE
  SubscribeAlarms and drains it after the first reconcile; window transitions
  buffer in the lease's bounded channel. Processing them after ApplyReconcile is
  order-safe (ApplyTransition handles alarms the snapshot already placed).
- ISessionManager.ReadAlarmEventsAsync removed — zero remaining callers.
- ApplyReconcile broadcasts an Acknowledge feed transition when a both-present
  alarm's state advanced to ActiveAcked. This is a feed-level repair on the
  AlarmFeedMessage/StreamAlarms surface rebuilt from the worker's own snapshot,
  not MxEvent emission, so the "never synthesize events" rule is untouched;
  the reasoning is recorded on ApplyReconcile.

The alarm-monitor test fakes now hand the monitor a real Ready GatewaySession
with a dashboard mirror, which is what makes the window reproducible.

Docs: docs/Sessions.md and gateway.md alarm-monitor ordering notes.

Refs: archreview/2026-07-12/remediation/10-gateway-core.md GWC-26

src/ZB.MOM.WW.MxGateway.Tests/Alarms/AlarmFailoverEndToEndTests.cs

@@ -8,6 +8,7 @@ using ZB.MOM.WW.MxGateway.Server.Alarms;
 using ZB.MOM.WW.MxGateway.Server.Configuration;
 using ZB.MOM.WW.MxGateway.Server.Metrics;
 using ZB.MOM.WW.MxGateway.Server.Sessions;
+using ZB.MOM.WW.MxGateway.Server.Workers;
 
 namespace ZB.MOM.WW.MxGateway.Tests.Alarms;
 
@@ -420,6 +421,9 @@ public sealed class AlarmFailoverEndToEndTests
             string? ownerKeyId,
             CancellationToken cancellationToken)
         {
+            // The monitor attaches its internal subscriber directly on this session, so the
+            // session has to be a genuinely Ready one with a worker client feeding the
+            // distributor pump — EmitEvent writes into that worker's event stream.
             GatewaySession session = new(
                 Guid.NewGuid().ToString("N"),
                 "Galaxy",
@@ -432,6 +436,8 @@ public sealed class AlarmFailoverEndToEndTests
                 TimeSpan.FromSeconds(30),
                 TimeSpan.FromSeconds(30),
                 DateTimeOffset.UtcNow);
+            session.AttachWorkerClient(new ChannelWorkerClient(session.SessionId, _events.Reader));
+            session.MarkReady();
             return Task.FromResult(session);
         }
 
@@ -460,29 +466,9 @@ public sealed class AlarmFailoverEndToEndTests
         }
 
         /// <inheritdoc />
-        public async IAsyncEnumerable<WorkerEvent> ReadEventsAsync(
+        public IAsyncEnumerable<WorkerEvent> ReadEventsAsync(
             string sessionId,
-            [EnumeratorCancellation] CancellationToken cancellationToken)
-        {
-            await foreach (WorkerEvent workerEvent in _events.Reader.ReadAllAsync(cancellationToken))
-            {
-                yield return workerEvent;
-            }
-        }
-
-        /// <inheritdoc />
-        public async IAsyncEnumerable<MxEvent> ReadAlarmEventsAsync(
-            string sessionId,
-            [EnumeratorCancellation] CancellationToken cancellationToken)
-        {
-            await foreach (WorkerEvent workerEvent in _events.Reader.ReadAllAsync(cancellationToken))
-            {
-                if (workerEvent.Event is not null)
-                {
-                    yield return workerEvent.Event;
-                }
-            }
-        }
+            CancellationToken cancellationToken) => throw new NotSupportedException();
 
         /// <inheritdoc />
         public bool TryGetSession(string sessionId, [MaybeNullWhen(false)] out GatewaySession session)
@@ -509,4 +495,50 @@ public sealed class AlarmFailoverEndToEndTests
         /// <inheritdoc />
         public Task ShutdownAsync(CancellationToken cancellationToken) => Task.CompletedTask;
     }
+
+    /// <summary>Ready worker client whose event stream is the fake session manager's channel.</summary>
+    private sealed class ChannelWorkerClient(string sessionId, ChannelReader<WorkerEvent> events) : IWorkerClient
+    {
+        /// <inheritdoc />
+        public string SessionId { get; } = sessionId;
+
+        /// <inheritdoc />
+        public int? ProcessId { get; } = 4321;
+
+        /// <inheritdoc />
+        public WorkerClientState State { get; } = WorkerClientState.Ready;
+
+        /// <inheritdoc />
+        public DateTimeOffset LastHeartbeatAt { get; } = DateTimeOffset.UtcNow;
+
+        /// <inheritdoc />
+        public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+        /// <inheritdoc />
+        public Task<WorkerCommandReply> InvokeAsync(
+            WorkerCommand command,
+            TimeSpan timeout,
+            CancellationToken cancellationToken) => Task.FromResult(new WorkerCommandReply());
+
+        /// <inheritdoc />
+        public async IAsyncEnumerable<WorkerEvent> ReadEventsAsync(
+            [EnumeratorCancellation] CancellationToken cancellationToken)
+        {
+            await foreach (WorkerEvent workerEvent in events.ReadAllAsync(cancellationToken).ConfigureAwait(false))
+            {
+                yield return workerEvent;
+            }
+        }
+
+        /// <inheritdoc />
+        public Task ShutdownAsync(TimeSpan timeout, CancellationToken cancellationToken) => Task.CompletedTask;
+
+        /// <inheritdoc />
+        public void Kill(string reason)
+        {
+        }
+
+        /// <inheritdoc />
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
 }