docs(src): add missing XML docs and strip tracking-ID comments

Sweep of 203 source files resolving CommentChecker findings: add
<summary>/<param>/<returns>/<inheritdoc> where missing, and remove
resolved task/issue tracking markers (Tests-NNN, Worker-NNN, Server-NNN,
Task N) from code comments. Comment/doc-only — no logic changes.
Server+Tests build clean under TreatWarningsAsErrors.

src/ZB.MOM.WW.MxGateway.Server/Grpc/EventStreamService.cs

@@ -13,13 +13,10 @@ public sealed class EventStreamService(
     IOptions<GatewayOptions> options,
     GatewayMetrics metrics) : IEventStreamService
 {
-    /// <summary>
-    ///     Streams events from a session to the client asynchronously.
-    /// </summary>
+    /// <inheritdoc />
     /// <remarks>
     ///     <para>
-    ///         Task 4 rewired this from a per-RPC channel that drained the session directly
-    ///         to reading the subscriber's lease channel fed by the session's single
+    ///         This reads the subscriber's lease channel fed by the session's single
     ///         <see cref="SessionEventDistributor"/> pump. The pump owns the single drain of
     ///         the worker event stream and the worker→public mapping (mirroring the former
     ///         <c>ProduceEventsAsync</c>); this loop is the per-subscriber boundary that
@@ -27,33 +24,28 @@ public sealed class EventStreamService(
     ///         and the backpressure/overflow policy.
     ///     </para>
     ///     <para>
-    ///         Task 6 moved the dashboard mirror OFF this per-RPC loop. The dashboard is now a
+    ///         The dashboard mirror runs OFF this per-RPC loop. The dashboard is a
     ///         first-class internal subscriber on the session's
     ///         <see cref="SessionEventDistributor"/> (see <c>GatewaySession.StartDashboardMirror</c>),
-    ///         so it receives session events even when no gRPC client is streaming. This loop no
-    ///         longer mirrors to the dashboard. One deliberate consequence: the dashboard now sees
+    ///         so it receives session events even when no gRPC client is streaming. This loop
+    ///         does not mirror to the dashboard. One deliberate consequence: the dashboard sees
     ///         RAW session events, not the per-gRPC-subscriber <c>AfterWorkerSequence</c>-filtered
     ///         view this loop applies — the dashboard is a separate LDAP-authenticated monitoring
-    ///         view that should see the session's full event activity (per-session dashboard ACL is
-    ///         the separate Task 18).
+    ///         view that should see the session's full event activity.
     ///     </para>
     ///     <para>
-    ///         Overflow handling (Task 5): the distributor's per-subscriber channel is bounded
+    ///         Overflow handling: the distributor's per-subscriber channel is bounded
     ///         and the pump writes non-blocking. When this subscriber's channel is full the pump
     ///         applies the per-subscriber backpressure policy and completes this subscriber's
     ///         channel with a <see cref="SessionManagerException"/>
     ///         (<see cref="SessionManagerErrorCode.EventQueueOverflow"/>). That terminal fault
-    ///         surfaces here when the reader's <c>MoveNextAsync</c> throws, and — like the
-    ///         pre-epic per-RPC overflow — it propagates to the gRPC client unchanged. The
-    ///         overflow metric, and (in the legacy single-subscriber FailFast case) the session
-    ///         fault + fault metric, are recorded by the distributor's overflow handler so the
-    ///         session, the pump, and other subscribers are isolated from this subscriber's
-    ///         slowness.
+    ///         surfaces here when the reader's <c>MoveNextAsync</c> throws, and it propagates to
+    ///         the gRPC client unchanged. The overflow metric, and (in the legacy
+    ///         single-subscriber FailFast case) the session fault + fault metric, are recorded by
+    ///         the distributor's overflow handler so the session, the pump, and other subscribers
+    ///         are isolated from this subscriber's slowness.
     ///     </para>
     /// </remarks>
-    /// <param name="request">Stream events request.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    /// <returns>Async enumerable of MX events.</returns>
     public async IAsyncEnumerable<MxEvent> StreamEventsAsync(
         StreamEventsRequest request,
         [EnumeratorCancellation] CancellationToken cancellationToken)
@@ -72,7 +64,7 @@ public sealed class EventStreamService(
         // the session's own SessionEventStreaming.AllowMultipleEventSubscribers field — the
         // same source the distributor uses — so the two cannot diverge.
         //
-        // Reconnect/resume (Task 12): when AfterWorkerSequence > 0 the client is resuming, so
+        // Reconnect/resume: when AfterWorkerSequence > 0 the client is resuming, so
         // attach via the replay variant that atomically snapshots the replay ring AND registers
         // the live subscriber under one lock. That single critical section is the crux of the
         // no-gap/no-duplicate handoff: every replayed event has sequence <= LiveResumeSequence
@@ -81,7 +73,7 @@ public sealed class EventStreamService(
         // channel is dropped exactly once, while no newer event is skipped. See
         // SessionEventDistributor.RegisterWithReplay for the full argument.
         //
-        // AfterWorkerSequence == 0 (fresh stream, not a resume) keeps the pre-Task-12 behavior:
+        // AfterWorkerSequence == 0 (fresh stream, not a resume) keeps the original behavior:
         // a plain attach, no replay, no sentinel, and the live filter watermark stays 0.
         ulong afterWorkerSequence = request.AfterWorkerSequence;
         IEventSubscriberLease subscriber;
@@ -157,7 +149,7 @@ public sealed class EventStreamService(
                 {
                     // The distributor pump completes every subscriber channel with the source
                     // fault when the worker event stream terminates abnormally; that surfaces
-                    // here. Mirror the pre-Task-4 ProduceEventsAsync behavior: fault the
+                    // here. Mirror the original ProduceEventsAsync behavior: fault the
                     // session and record the metric, then propagate the terminal fault to the
                     // gRPC client.
                     session.MarkFaulted(workerException.Message);
@@ -175,7 +167,7 @@ public sealed class EventStreamService(
 
                 // Queue-depth gauge tracks events the pump has fanned into this subscriber's
                 // channel but the client has not yet consumed — the same "buffered, not yet
-                // delivered" quantity the pre-Task-4 per-RPC channel reported. The bounded
+                // delivered" quantity the original per-RPC channel reported. The bounded
                 // subscriber channel supports counting, so reconcile the gauge to the current
                 // backlog; falling back to a no-op delta if a channel ever cannot count.
                 int backlog = subscriber.Reader.CanCount ? subscriber.Reader.Count : streamQueueDepth;