De-reflect cursor tests; de-flake poison timing

Two test-quality fixes in the send-loop cursor suite; no production
behavior change.

De-reflection. CatchUpAlignmentTest, PoisonFrameTest, TornDictGuardTest
and MirrorLeakTest reached into CursorWebSocketSendLoop by reflection --
reading private constants and fields, invoking private methods, and
writing private state -- so a rename broke them as a runtime
ReflectiveOperationException instead of a compile error. Add @testonly
accessors and thin ...ForTest wrappers on CursorWebSocketSendLoop, each
delegating verbatim to the same private member, and make
forceMirrorSeedFailureForTest public; then rewire the four tests to call
them. The rewrites drive the identical production paths, and the
mirror-overflow guard now catches the exact public LineSenderException
type rather than unwrapping an InvocationTargetException.

De-flake. PoisonFrameTest asserted absolute wall-clock bounds -- a
recycle is "immediate" under 300 ms, and a recycle count fits a fixed
sleep window -- that a CI GC pause or starved scheduler can trip.
Replace them with predicates only a real regression fails: consecutive
recycle gaps must clear 3/4 of the reconnect backoff (an unpaced loop's
sub-millisecond gaps fail, while a slow test thread only yields more
paced samples); the deterministic zeroProgressRecycles branch value
(level 0, then 1, then reset on progress); a first*2 <= second relative
bound; and the kept second >= backoff lower bound, which starvation can
only lengthen. Split the dwell test into a huge-window case (threshold
reached, window still open, so no escalation -- asserting poisonStrikes
== 3) and a small-window case crossed by a sleep strictly longer than
the window, which must escalate to the PROTOCOL_VIOLATION terminal.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: glasstiger

core/src/main/java/io/questdb/client/cutlass/qwp/client/sf/cursor/CursorWebSocketSendLoop.java

@@ -206,7 +206,7 @@ public final class CursorWebSocketSendLoop implements QuietCloseable {
     // deleted. Production never sets it; volatile only so a test thread's write is
     // visible to the loop under test.
     @TestOnly
-    static volatile boolean forceMirrorSeedFailureForTest;
+    public static volatile boolean forceMirrorSeedFailureForTest;
     // Pre-converted to nanos for the comparison in sendDurableAckKeepaliveIfDue.
     // Zero or negative disables the keepalive entirely.
     private final long durableAckKeepaliveIntervalNanos;
@@ -1091,6 +1091,16 @@ public static boolean isTerminalCloseCode(int code) {
         }
     }
 
+    @TestOnly
+    public static int maxCatchUpCapGapAttempts() {
+        return MAX_CATCHUP_CAP_GAP_ATTEMPTS;
+    }
+
+    @TestOnly
+    public static int maxSentDictBytes() {
+        return MAX_SENT_DICT_BYTES;
+    }
+
     /**
      * Surfaces any error the I/O thread recorded. Called by the producer
      * thread (typically from inside its append wrapper) so failures don't
@@ -2895,6 +2905,140 @@ public int catchUpFrameGrowthCount() {
         return catchUpFrameGrowthCount;
     }
 
+    @TestOnly
+    public int catchUpCapGapAttempts() {
+        return catchUpCapGapAttempts;
+    }
+
+    @TestOnly
+    public long catchUpCapGapFirstNanos() {
+        return catchUpCapGapFirstNanos;
+    }
+
+    @TestOnly
+    public long catchUpCapGapMinEscalationWindowNanos() {
+        return catchUpCapGapMinEscalationWindowNanos;
+    }
+
+    @TestOnly
+    public long fsnAtZero() {
+        return fsnAtZero;
+    }
+
+    @TestOnly
+    public long poisonFsn() {
+        return poisonFsn;
+    }
+
+    @TestOnly
+    public int poisonStrikes() {
+        return poisonStrikes;
+    }
+
+    @TestOnly
+    public long sentDictBytesAddr() {
+        return sentDictBytesAddr;
+    }
+
+    @TestOnly
+    public int sentDictBytesLen() {
+        return sentDictBytesLen;
+    }
+
+    @TestOnly
+    public boolean sentDictBytesOwned() {
+        return sentDictBytesOwned;
+    }
+
+    @TestOnly
+    public int sentDictCount() {
+        return sentDictCount;
+    }
+
+    @TestOnly
+    public int zeroProgressRecycles() {
+        return zeroProgressRecycles;
+    }
+
+    @TestOnly
+    public void accumulateSentDictForTest(long payloadAddr, int payloadLen, int deltaStart) {
+        accumulateSentDict(payloadAddr, payloadLen, deltaStart);
+    }
+
+    @TestOnly
+    public void connectLoopForTest(Throwable initial, String phase, long paceFirstAttemptMillis) {
+        connectLoop(initial, phase, paceFirstAttemptMillis);
+    }
+
+    @TestOnly
+    public void deliverCloseForTest(int code, String reason) {
+        responseHandler.onClose(code, reason);
+    }
+
+    @TestOnly
+    public void deliverResponseForTest(long payloadPtr, int payloadLen) {
+        responseHandler.onBinaryMessage(payloadPtr, payloadLen);
+    }
+
+    @TestOnly
+    public void ensureSentDictCapacityForTest(long required) {
+        ensureSentDictCapacity(required);
+    }
+
+    @TestOnly
+    public void positionCursorForStartForTest() {
+        positionCursorForStart();
+    }
+
+    @TestOnly
+    public void seedSentDictMirrorForTest(long addr, int bytes, int symbolCount) {
+        sentDictBytesAddr = addr;
+        sentDictBytesCapacity = bytes;
+        sentDictBytesLen = bytes;
+        sentDictCount = symbolCount;
+        sentDictBytesOwned = true;
+    }
+
+    @TestOnly
+    public void sendCatchUpChunkForTest(int deltaStart, int deltaCount, long symbolsAddr, int symbolsLen) {
+        sendCatchUpChunk(deltaStart, deltaCount, symbolsAddr, symbolsLen);
+    }
+
+    @TestOnly
+    public void setCatchUpCapGapFirstNanosForTest(long nanos) {
+        catchUpCapGapFirstNanos = nanos;
+    }
+
+    @TestOnly
+    public void setDataFrameSentThisConnectionForTest(boolean value) {
+        dataFrameSentThisConnection = value;
+    }
+
+    @TestOnly
+    public void setFsnAtZeroForTest(long value) {
+        fsnAtZero = value;
+    }
+
+    @TestOnly
+    public void setNextWireSeqForTest(long value) {
+        nextWireSeq = value;
+    }
+
+    @TestOnly
+    public void setRunningForTest(boolean value) {
+        running = value;
+    }
+
+    @TestOnly
+    public void setWireBaselineWithCatchUpForTest(long replayStart) {
+        setWireBaselineWithCatchUp(replayStart);
+    }
+
+    @TestOnly
+    public boolean trySendOneForTest() {
+        return trySendOne();
+    }
+
     private void ensureCatchUpFrameCapacity(int required) {
         if (catchUpFrameCapacity >= required) {
             return;