feat(net): N6 - ConnectResponse retransmit + fragment assembler eviction

Campaign N Slice N6, the final implementation slice.

ConnectResponse handshake retransmit:
- While the connection is unconfirmed, the Connect character-list pump
  resends the IDENTICAL cleartext ConnectResponse (same sequence 1, same
  cookie, the one encoded datagram - no new outbound state) on retail's
  strict 0.333333333 s gate. Retail: ClientNet::ProcessConnection
  @ 0x00545450, case cs_ConnectionRequestAcked @ 0x0054547B (the constant
  load at 0x00545481; the mask-0x41 strictly-greater x87 test at
  0x0054548C); ClientNet::SendConnectAck @ 0x005440F0 re-stamps
  lastSentHandshake_ (0x00544102) and rebuilds the same cookie packet.
- Confirmation = the first checksum-valid post-negotiation packet whose
  header lacks the ConnectRequest flag: retail's cs_ConnectionRequestAcked
  -> cs_Connected edge (ClientNet::ProcessPacket @ 0x00545100, the 0x40000
  exclusion at 0x0054514E, SetConnectionState(..., 5) at 0x00545160).
- The cadence rides the TransportClock (virtual-clock testable through
  TransportClockSource); the Connect deadline stays wall-clock.
- ACE safety pinned against the N0 model: a duplicate while still
  AuthConnectResponse re-routes idempotently through NetworkManager's
  pre-route; after acceptance CheckState clause 2 drops it pre-CRC at
  zero keystream cost.
- Pre-N6, one lost ConnectResponse was a hang to the Connect deadline;
  the N5 decorator deliberately arms after this window, so nothing
  covered it.

FragmentAssembler eviction (divergence register row AD-52):
- Partials evict 60 s after their last ACCEPTED fragment; the stamp
  refreshes on every new fragment (retail's re-stamp rule,
  ArrivedEphInfo::UpdateNetBlobID @ 0x0054AE00), so a merely-slow partial
  can never age out - 60 s is a floor, not a tunable. Swept from
  ReliableTransport.Sweep on retail's 5 s flush cadence
  (Indicator::FlushTimedOutEphInfo @ 0x0054A3D0, the gate at 0x0054A3DC;
  per-entry ArrivedEphInfo::fTimedOut @ 0x0054AE30). N4's RejectRetransmit
  abandonment made an unrecoverable partial a REACHABLE permanent state;
  the TTL reclaims it.
- A 64-entry completed-sequence ring drops late duplicate fragments of
  already-completed messages instead of allocating a fresh partial that
  can never complete (the completed-then-duplicate leak).

Fold-ins:
- N5 review LOW-5: NetProbeTests + LossyTransportDecoratorTests (the
  static NetDiagnostics / Console.SetOut mutators) share one
  DisableParallelization xunit collection so they never run alongside
  classes constructing WorldSession.
- Campaign section 9: N6 ledger row recorded; N5 row verified carrying
  4e290f00.

Gates: 757 Core.Net Release tests green (10 new); full solution Release
green (0 failures / 5 skips); connected lifecycle gate PASS; the
N5-strengthened connected loss gate PASS on its first live run (2%/seed 1:
dropped out=3 in=10, resends=1 nak-in=1 nak-out=5, cksum-fail=0
sanity-drop=0 uncached-nak=0).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

src/AcDream.Core.Net/Transport/ReliableTransport.cs

@@ -1,5 +1,6 @@
 using System.Buffers;
 using AcDream.Core.Net.Cryptography;
+using AcDream.Core.Net.Packets;
 
 namespace AcDream.Core.Net.Transport;
 
@@ -40,6 +41,19 @@ internal sealed class ReliableTransport : IDisposable
 
     public TransportStats Stats { get; }
 
+    /// <summary>
+    /// N6: retail's ephemeral-info flush cadence
+    /// (<c>Indicator::FlushTimedOutEphInfo @ 0x0054A3D0</c>, the x87 compare
+    /// against 5.0 at 0x0054A3DC) — how often the sweep asks the fragment
+    /// assembler to evict aged partials. The per-entry TTL itself lives in
+    /// <see cref="FragmentAssembler.PartialTtlSeconds"/> (AD-52).
+    /// </summary>
+    public const double AssemblerSweepSeconds = 5.0;
+
+    private readonly FragmentAssembler? _assembler;
+    private readonly long _assemblerSweepTicks;
+    private long _assemblerSweepTimestamp;
+
     public ReliableTransport(
         IsaacRandom outboundIsaac,
         IsaacRandom inboundIsaac,
@@ -47,10 +61,16 @@ internal sealed class ReliableTransport : IDisposable
         ushort sessionIteration,
         DatagramSendDelegate send,
         TransportClock? clock = null,
-        ArrayPool<byte>? pool = null)
+        ArrayPool<byte>? pool = null,
+        FragmentAssembler? assembler = null)
     {
         Clock = clock ?? new TransportClock();
         Stats = new TransportStats();
+        _assembler = assembler;
+        // Same defensive rounding as the scheduler gates (N4 review F1).
+        _assemblerSweepTicks =
+            (long)Math.Round(AssemblerSweepSeconds * Clock.Frequency);
+        _assemblerSweepTimestamp = Clock.GetTimestamp();
         Outbound = new OutboundFlowQueue(
             outboundIsaac,
             sessionClientId,
@@ -91,8 +111,19 @@ internal sealed class ReliableTransport : IDisposable
     public void Sweep()
     {
         Clock.Update();
-        Scheduler.Sweep(Clock.GetTimestamp());
+        long now = Clock.GetTimestamp();
+        Scheduler.Sweep(now);
         Outbound.TransmitPendingResends();
+
+        // N6: age out abandoned fragment partials on retail's 5 s flush
+        // cadence (Indicator::FlushTimedOutEphInfo @ 0x0054A3D0 — re-stamp
+        // the flush clock, then walk the table dropping timed-out entries).
+        if (_assembler is not null
+            && now - _assemblerSweepTimestamp >= _assemblerSweepTicks)
+        {
+            _assemblerSweepTimestamp = now;
+            _assembler.SweepExpired();
+        }
     }
 
     /// <summary>Returns every rented cache buffer to the pool.</summary>