docs: strip task-tracking IDs from code comments and fill missing XML docs

Tracking IDs are review bookkeeping that rots in shipped source; the rationale they tagged is kept. Comment-only change (CommentChecker 458 -> 16 false positives).

src/ZB.MOM.WW.MxGateway.Tests/Gateway/Workers/WorkerClientTests.cs

@@ -36,10 +36,10 @@ public sealed class WorkerClientTests
 
     /// <summary>
     ///     The <c>GatewayHello</c> carries the negotiated worker-frame maximum so the worker adopts the
-    ///     configured limit instead of its own default (IPC-02); a regression to sending <c>0</c> means
+    ///     configured limit instead of its own default; a regression to sending <c>0</c> means
     ///     "older gateway, use default" to the worker and would silently downgrade the negotiated limit.
     ///     The adoption half is asserted only in the Windows-only worker suite, so the gateway half is
-    ///     pinned here, in the portable suite (TST-28). Both the default and an override are covered so
+    ///     pinned here, in the portable suite. Both the default and an override are covered so
     ///     the assertion tracks configuration rather than a constant.
     /// </summary>
     /// <param name="maxMessageBytes">Configured worker-frame maximum to negotiate.</param>
@@ -164,7 +164,7 @@ public sealed class WorkerClientTests
             TestTimeout,
             CancellationToken.None);
 
-        // The timeout also emits a WorkerCancel for the abandoned correlation (PERF-07), which sits
+        // The timeout also emits a WorkerCancel for the abandoned correlation, which sits
         // ahead of the second command on the FIFO pipe; skip it rather than mistaking it for the
         // command this assertion is about.
         WorkerEnvelope secondCommand = await ReadNextCommandAsync(pipePair, timedOutCommand.CorrelationId);
@@ -180,7 +180,7 @@ public sealed class WorkerClientTests
     /// <summary>
     ///     A command timeout abandons the gateway-side wait, but the worker keeps the correlation on
     ///     its single STA queue and would still run it — so the gateway forwards a <c>WorkerCancel</c>
-    ///     for the abandoned correlation id (PERF-07). Without it, a client that retries after a
+    ///     for the abandoned correlation id. Without it, a client that retries after a
     ///     timeout stacks work the worker still intends to execute. Asserted on the wire because the
     ///     cancel is protocol behavior the worker depends on, not an internal detail.
     /// </summary>
@@ -223,7 +223,7 @@ public sealed class WorkerClientTests
     /// <summary>
     ///     Caller cancellation abandons the correlation exactly as a gateway timeout does — a client
     ///     deadline shorter than the gateway's command timeout, or a disconnect, is the common
-    ///     abandonment path — so it forwards the same <c>WorkerCancel</c> (IPC-34). Without it a
+    ///     abandonment path — so it forwards the same <c>WorkerCancel</c>. Without it a
     ///     retry storm of deadline-cancelled calls leaves the worker's single STA working through
     ///     commands nobody is waiting for while live callers queue behind them. Twin of
     ///     <see cref="InvokeAsync_WhenCommandTimesOut_SendsWorkerCancelForThatCorrelation"/>, driven
@@ -271,7 +271,7 @@ public sealed class WorkerClientTests
 
     /// <summary>
     ///     The cancel is forwarded for a caller that abandoned its command, never for the client's own
-    ///     teardown (IPC-34): once the stop token has fired the outbound channel is being completed and
+    ///     teardown: once the stop token has fired the outbound channel is being completed and
     ///     every pending command is failed anyway, so a cancel would at best be pointless and at worst
     ///     a write racing teardown. Asserted on the wire — the guard in the cancellation arm is the
     ///     code-level expression of it, and the completed outbound channel is the second line of
@@ -330,8 +330,7 @@ public sealed class WorkerClientTests
     ///     A <c>WorkerFault</c> arriving in place of a handshake frame is the worker reporting a
     ///     structured startup failure — most often MXAccess COM creation — not a protocol problem, so
     ///     the gateway surfaces <see cref="WorkerClientErrorCode.WorkerFaulted"/> with the fault's
-    ///     category and diagnostic rather than a generic protocol violation naming only the body type
-    ///     (IPC-35). This is the window where the information matters most: first session open on a
+    ///     category and diagnostic rather than a generic protocol violation naming only the body type. This is the window where the information matters most: first session open on a
     ///     freshly deployed host, where the message reaches the operator log and the client's
     ///     <c>OpenFailed</c> detail.
     /// </summary>
@@ -368,8 +367,7 @@ public sealed class WorkerClientTests
     /// <summary>
     ///     The envelope <c>sequence</c> is a monotonic per-sender counter (gateway.md), so the values
     ///     observed on the pipe must be strictly increasing in wire order. Stamping the sequence when
-    ///     the envelope is constructed lets two concurrent invokes stamp 1 and 2 but enqueue 2 then 1
-    ///     (GWC-28); stamping on the single-consumer write loop makes wire order and sequence order the
+    ///     the envelope is constructed lets two concurrent invokes stamp 1 and 2 but enqueue 2 then 1; stamping on the single-consumer write loop makes wire order and sequence order the
     ///     same thing by construction.
     /// </summary>
     /// <returns>A task that represents the asynchronous operation.</returns>
@@ -710,12 +708,12 @@ public sealed class WorkerClientTests
     }
 
     /// <summary>
-    ///     GWC-32: disposing a still-<c>Ready</c> client while the worker is emitting events must be
+    ///     Disposing a still-<c>Ready</c> client while the worker is emitting events must be
     ///     an ordinary teardown, not a fault. <c>DisposeAsync</c> completes the same three channels
     ///     <c>MarkClosed</c> and <c>SetFaulted</c> do, so it must enter a terminal state first;
     ///     otherwise the read loop — already inside <c>DispatchEnvelope</c> when the staging channel
     ///     is completed, or reading a stream that is torn down underneath it — misdiagnoses the
-    ///     completed channel as the GWC-24 sustained-backpressure overflow and raises a spurious
+    ///     completed channel as the sustained-backpressure overflow and raises a spurious
     ///     <c>ProtocolViolation</c> fault, a <c>worker-event-staging</c> overflow metric and a
     ///     redundant kill during an intentional dispose. The event channel is sized far above the
     ///     burst so a genuine overflow is impossible, and <c>DisposeAsync</c> awaits its background
@@ -726,7 +724,7 @@ public sealed class WorkerClientTests
     public async Task DisposeAsync_WhileWorkerIsEmittingEvents_ClosesWithoutFaultingOrOverflowing()
     {
         // The burst is capped at EmittedEventCeiling and the staging channel holds 2 x capacity, so
-        // even if every emitted event were staged and none consumed the GWC-24 bound is unreachable:
+        // even if every emitted event were staged and none consumed the staging bound is unreachable:
         // an overflow metric in this test can only be the dispose-race misdiagnosis.
         const int capacity = 2048;
         using GatewayMetrics metrics = new();
@@ -1007,13 +1005,13 @@ public sealed class WorkerClientTests
     }
 
     /// <summary>
-    ///     GWC-24: the staging channel between the read loop and the event writer is bounded at
+    ///     The staging channel between the read loop and the event writer is bounded at
     ///     2 × <see cref="WorkerClientOptions.EventChannelCapacity"/>, so a consumer that drains
     ///     slower than the worker produces faults the client at the bound instead of growing
     ///     gateway memory silently. The full-mode timeout here is far longer than the test could
     ///     ever wait, which proves the fault came from the staging bound and not from the timed
     ///     write in <c>EnqueueWorkerEventAsync</c>. A command reply interleaved before the fault
-    ///     must still complete: the read loop never blocks behind events (the GWC-04 guarantee).
+    ///     must still complete: the read loop never blocks behind events (the read-loop guarantee).
     /// </summary>
     /// <returns>A task that represents the asynchronous operation.</returns>
     [Fact]
@@ -1094,7 +1092,7 @@ public sealed class WorkerClientTests
     }
 
     /// <summary>
-    ///     GWC-24: the worker event queue-depth gauge counts staged *and* queued events, so a
+    ///     The worker event queue-depth gauge counts staged *and* queued events, so a
     ///     backlog held in the staging channel is visible rather than invisible. Depth is
     ///     incremented at staging and decremented when the consumer reads, so the single counter
     ///     reports total undelivered events and returns to zero once drained.
@@ -1148,7 +1146,7 @@ public sealed class WorkerClientTests
     }
 
     /// <summary>
-    ///     GWC-33: a faulted client can remain retained for diagnostics, but its abandoned event
+    ///     A faulted client can remain retained for diagnostics, but its abandoned event
     ///     backlog must stop contributing to the gateway-wide queue-depth gauge as soon as the
     ///     client enters a terminal state rather than waiting for disposal.
     /// </summary>