fix(IPC-33): bound the DrainEvents byte budget against the gRPC send cap, not just the pipe frame max

The worker budgeted a DrainEvents reply against the negotiated pipe frame
maximum less one 64 KiB reserve, but the gateway returns that same
MxCommandReply verbatim through Invoke, where MaxSendMessageSize applies. The
two limits were coupled only from below (pipe >= gRPC + reserve), so any
configuration the validator permitted with a wider gap let the worker pack a
reply the pipe carried and the gRPC layer then refused with ResourceExhausted --
after Drain had already removed the events from the worker queue, losing them to
both the caller and the event stream.

Option (a) from the finding: close the coupling at both ends.

- GatewayOptionsValidator adds the upper half of the headroom rule
  (Worker:MaxMessageBytes <= Protocol:MaxGrpcMessageBytes + 2 x reserve), with a
  message naming the DrainEvents budget as the reason and the two knobs to move.
- WorkerPipeSession.ResolveDrainReplyByteBudget subtracts the reserve twice --
  once for the pipe frame, once so the MxCommandReply wrapper clears the gRPC
  send cap -- keeping the MaxMessageBytes/2 floor that makes small frame maxima
  usable.

The two changes are load-bearing for each other: the validator band is what
makes "frame max - 2 x reserve" provably at or below the gRPC cap, and the
doubled subtraction is what makes the band sufficient.

Docs updated in the same change (GatewayConfiguration.md both option rows plus
the headroom prose, WorkerFrameProtocol.md drain budget, gateway.md DrainEvents
byte axis). Tests: new GatewayOptionsValidatorTests cases for the upper bound
(reject) and both edges of the band (accept); GatewayOptionsTests' override case
now moves both message-size knobs together, since the band makes moving one
alone illegal.

The worker half cannot be built on macOS; verified on windev separately.

src/ZB.MOM.WW.MxGateway.Worker.Tests/Ipc/WorkerPipeSessionTests.cs

@@ -692,7 +692,7 @@ public sealed class WorkerPipeSessionTests
     /// <summary>
     ///     Regression for the reserve-boundary budget bug. The gateway validator accepts a Worker
     ///     frame maximum as low as 1024 + 64 KiB, and just above that boundary a naive
-    ///     subtract-then-guard budget collapses to ~1024 bytes — too small to move even one
+    ///     subtract-then-guard budget collapses to nothing — too small to move even one
     ///     byte-heavy event, so every drain reports truncation with the same head blocked and the
     ///     drain-until-empty loop never terminates. The budget is now a floor (never below half the
     ///     negotiated maximum), so a byte-heavy queue drains to empty even at the validator floor.
@@ -702,8 +702,9 @@ public sealed class WorkerPipeSessionTests
     public async Task DrainEvents_AtValidatorFloorFrameMax_MakesProgressAndTerminates()
     {
         // The lowest Worker.MaxMessageBytes GatewayOptionsValidator permits: the public gRPC floor
-        // (1024) plus the 64 KiB envelope-overhead reserve. The naive budget would be exactly 1024
-        // here; the floored budget is half of the frame max (~33 KiB).
+        // (1024) plus the 64 KiB envelope-overhead reserve. The naive budget — frame max less the
+        // two reserves the DrainEvents budget subtracts (IPC-33) — would be negative here; the
+        // floored budget is half of the frame max (~33 KiB).
         const uint validatorFloorFrameMax = 1024 + (64 * 1024);
         using CancellationTokenSource cancellation = new(TimeSpan.FromSeconds(60));
         using PipePair pipePair = await PipePair.CreateAsync(cancellation.Token);