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.Server/Workers/WorkerClient.cs

@@ -28,7 +28,7 @@ public sealed class WorkerClient : IWorkerClient
     // Staging hand-off between the read loop and the dedicated event writer. The read loop writes
     // here with a non-blocking TryWrite so a full consumer channel (_events) can never stall the read
     // loop behind an event — replies and heartbeats keep flowing. Bounded at 2 × EventChannelCapacity
-    // (GWC-24): an unbounded staging channel let a consumer that drains slower than the worker
+    // because an unbounded staging channel let a consumer that drains slower than the worker
     // produces grow gateway memory without limit and without a fault, because each individual timed
     // write into _events still completed inside EventChannelFullModeTimeout. A rejected TryWrite here
     // is the sustained-slow-drain signal and faults the client immediately (ProtocolViolation), which
@@ -41,7 +41,7 @@ public sealed class WorkerClient : IWorkerClient
     private readonly SemaphoreSlim _pendingCommandSlots;
     private readonly CancellationTokenSource _stopCts = new();
 
-    // PERF-02: this client's contribution to the gateway-wide worker queue-depth gauge. Registered
+    // this client's contribution to the gateway-wide worker queue-depth gauge. Registered
     // once here and read only when the gauge is scraped, so staging and consuming an event cost an
     // Interlocked on _eventQueueDepth and nothing else — previously each of those two hot-path steps
     // called into GatewayMetrics and took its process-wide lock. Null when metrics are disabled.
@@ -233,13 +233,13 @@ public sealed class WorkerClient : IWorkerClient
             // size the caller controls; checking here keeps a MessageTooLarge in the write loop a
             // genuine desync signal.
             //
-            // PERF-07: this size cannot be handed to WorkerFrameWriter to spare its own
+            // this size cannot be handed to WorkerFrameWriter to spare its own
             // CalculateSize. WriteLoopAsync stamps envelope.Sequence immediately before the write
-            // (GWC-28), and a non-zero varint field grows the encoding — so the number computed here
+            // and a non-zero varint field grows the encoding — so the number computed here
             // is a lower bound on the frame the writer actually emits, never the frame length. Passing
             // it as a knownSize would under-length the prefix and desync the worker's framing.
             //
-            // IPC-39: being a lower bound is conservative for the knownSize question but the wrong
+            // being a lower bound is conservative for the knownSize question but the wrong
             // direction for this pre-check, which must not admit an envelope the writer will then
             // reject with a session-fatal MessageTooLarge. Compare against the frame maximum less the
             // MaxSequenceEncodingBytes the stamp can add, so every envelope this check accepts still
@@ -257,7 +257,7 @@ public sealed class WorkerClient : IWorkerClient
 
             await EnqueueAsync(commandEnvelope, cancellationToken).ConfigureAwait(false);
 
-            // PERF-07: one pooled timer instead of a linked CTS + Task.Delay + WhenAny per command.
+            // one pooled timer instead of a linked CTS + Task.Delay + WhenAny per command.
             // Task.WaitAsync arms a TimerQueueTimer on the shared timer queue and cancels it when the
             // reply lands, so the steady-state cost of a command that replies in time is a single
             // continuation — the old shape allocated a linked CancellationTokenSource, its
@@ -354,7 +354,7 @@ public sealed class WorkerClient : IWorkerClient
     {
         await foreach (WorkerEvent workerEvent in _events.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))
         {
-            // No metrics call on the hot path: the gauge pulls _eventQueueDepth when scraped (PERF-02).
+            // No metrics call on the hot path: the gauge pulls _eventQueueDepth when scraped.
             Interlocked.Decrement(ref _eventQueueDepth);
             yield return workerEvent;
         }
@@ -420,7 +420,7 @@ public sealed class WorkerClient : IWorkerClient
     /// <returns>A task that represents the asynchronous operation.</returns>
     public async ValueTask DisposeAsync()
     {
-        // GWC-32: disposal is the third channel-completing path, and it must enter a terminal state
+        // disposal is the third channel-completing path, and it must enter a terminal state
         // like the other two (MarkClosed, SetFaulted) BEFORE the channels are completed. Otherwise a
         // client disposed while still Ready keeps reporting IsTerminalState() == false, and a read
         // loop already inside DispatchEnvelope (the _stopCts.Cancel below only interrupts the NEXT
@@ -490,7 +490,7 @@ public sealed class WorkerClient : IWorkerClient
     ///     Worst-case number of bytes <see cref="WriteLoopAsync"/>'s sequence stamp adds to an
     ///     envelope that was sized before it: one tag byte plus a ten-byte varint, the maximum
     ///     encoding of a 64-bit protobuf field. The <c>CommandTooLarge</c> pre-check subtracts this
-    ///     from the negotiated frame maximum (IPC-39) because it measures the envelope while
+    ///     from the negotiated frame maximum because it measures the envelope while
     ///     <c>Sequence</c> is still 0 — an unset field costs nothing to encode, so the measured size
     ///     is a lower bound on the frame the writer emits, and without the allowance an envelope in
     ///     the last eleven bytes of the range would pass the pre-check and then fault the session on
@@ -505,12 +505,12 @@ public sealed class WorkerClient : IWorkerClient
         {
             await foreach (WorkerEnvelope envelope in _outboundEnvelopes.Reader.ReadAllAsync(_stopCts.Token).ConfigureAwait(false))
             {
-                // GWC-28: stamp the sequence at the point of writing, not when the envelope is built.
+                // stamp the sequence at the point of writing, not when the envelope is built.
                 // Stamping at construction let two concurrent InvokeAsync callers take 1 and 2 and then
                 // enqueue in the order 2, 1 — non-monotonic on the wire, breaking gateway.md's
                 // "monotonic per sender" contract. This loop is the channel's single consumer
                 // (SingleReader = true), so wire order and stamp order are the same thing here and
-                // _nextSequence needs no interlocking. Mirrors the worker's WRK-04 fix.
+                // _nextSequence needs no interlocking. Mirrors the worker's equivalent fix.
                 envelope.Sequence = unchecked(++_nextSequence);
                 await _writer.WriteAsync(envelope, _stopCts.Token).ConfigureAwait(false);
             }
@@ -678,11 +678,11 @@ public sealed class WorkerClient : IWorkerClient
     ///     faults regardless of how backed up the event path is. It returns <c>false</c> in two cases:
     ///     the staging channel has been completed by one of the three completing paths —
     ///     <see cref="MarkClosed"/>, <see cref="SetFaulted"/> or <see cref="DisposeAsync"/>, each of
-    ///     which enters a terminal state before completing the channels (GWC-32), so the event is
+    ///     which enters a terminal state before completing the channels, so the event is
     ///     safely dropped because the client is already terminal — or the channel is full at its
     ///     2 × <see cref="WorkerClientOptions.EventChannelCapacity"/> bound. The latter means the
     ///     consumer has been draining slower than the worker produces for the whole time it took the
-    ///     worker to emit that many further events, so the client is faulted immediately (GWC-24) —
+    ///     worker to emit that many further events, so the client is faulted immediately —
     ///     <see cref="SetFaulted"/> is non-blocking, so the read loop still never awaits here. The
     ///     complementary full-stall case (a consumer that stops entirely) is caught earlier by the
     ///     timed write in <see cref="EnqueueWorkerEventAsync"/>.
@@ -753,7 +753,7 @@ public sealed class WorkerClient : IWorkerClient
     ///     the actionable fix (attach <c>StreamEvents</c> or raise
     ///     <c>MxGateway:Events:QueueCapacity</c>). This is the full-stall half of
     ///     the backpressure policy; a consumer that merely drains too slowly is
-    ///     caught by the staging bound in <see cref="StageWorkerEvent"/> (GWC-24).
+    ///     caught by the staging bound in <see cref="StageWorkerEvent"/>.
     ///     Queue depth is not counted here — the event was already counted when it
     ///     was staged, so moving it between the two channels changes nothing.
     /// </summary>
@@ -851,7 +851,7 @@ public sealed class WorkerClient : IWorkerClient
     /// <summary>
     ///     Fails the pending command for a caller whose own token fired — a client deadline shorter
     ///     than the gateway's command timeout, or a disconnect that cancelled the RPC's token — and
-    ///     forwards a <c>WorkerCancel</c> for the correlation the caller has abandoned (IPC-34).
+    ///     forwards a <c>WorkerCancel</c> for the correlation the caller has abandoned.
     ///     <para>
     ///     Caller cancellation is the common abandonment path, not the rare one, and it leaves the
     ///     worker in exactly the state the timeout arm's cancel exists for: the correlation is still
@@ -982,7 +982,7 @@ public sealed class WorkerClient : IWorkerClient
     {
         WorkerEnvelope envelope = await _reader.ReadAsync(cancellationToken).ConfigureAwait(false);
 
-        // IPC-35: a fault frame during the handshake is the worker reporting a structured startup
+        // a fault frame during the handshake is the worker reporting a structured startup
         // failure — most often MXAccess COM creation (not installed, not registered, access denied)
         // — not a protocol problem. Flattening it to ProtocolViolation discarded the category and
         // diagnostic exactly where they matter most: first session open on a freshly deployed host,
@@ -1303,7 +1303,7 @@ public sealed class WorkerClient : IWorkerClient
         string correlationId,
         WorkerCommand command)
     {
-        // IPC-05: no second clone. MxAccessGrpcMapper.MapCommand already deep-cloned the command
+        // no second clone. MxAccessGrpcMapper.MapCommand already deep-cloned the command
         // out of the caller-owned gRPC MxCommandRequest, so this WorkerCommand is a fresh graph
         // owned by the invoke pipeline and referenced by no other consumer. The envelope is built
         // and owned entirely inside WorkerClient and the command is not touched again after this
@@ -1340,7 +1340,7 @@ public sealed class WorkerClient : IWorkerClient
     {
         // Sequence is deliberately left unset here: WriteLoopAsync stamps it immediately before the
         // frame goes out, so the numbers are monotonic in wire order however the callers interleave
-        // between construction and enqueue (GWC-28, mirroring the worker's WRK-04 fix).
+        // between construction and enqueue (mirroring the worker's fix).
         WorkerEnvelope envelope = new()
         {
             ProtocolVersion = _connection.FrameOptions.ProtocolVersion,