fix(qwp): give capacity-starved borrows a final retired-slot probe before the timeout check

borrow() ran the terminal timeout check before reprobeRetiredSlots(), so a
zero-timeout (try-once) borrow threw without its one probe, and a borrower
whose awaitNanos budget expired mid-wait timed out on capacity that a
deferred engine cleanup had already returned (the delegate-side flock
release never signals slotReleased). Hoist the probe above the timeout
check so both paths recover the capacity instead of failing.

Also pre-size retiredSlots to maxSize: every entry keeps a distinct
in-range slot index reserved, so add() can never grow the backing array --
a retire (leakedSlots++ then add, under lock) can no longer fail on
allocation and strand a counted-but-untracked slot that
reprobeRetiredSlots() could never recover.

Tests:
- testZeroTimeoutBorrowProbesRetiredSlotBeforeThrowing (red pre-fix)
- testParkedBorrowerGetsFinalProbeAfterBudgetExpiry (red pre-fix)
- testPoolRetiresAndRecoversSlotThroughRealManagerWorkerWedge: full-stack
  retire/recover cycle with no forged flags -- real wedged manager worker,
  real timed-out close handoff, real flock release, and a re-borrow on the
  recovered index proving the slot dir is genuinely reusable

Author: bluestreak01

core/src/main/java/io/questdb/client/impl/SenderPool.java

@@ -187,8 +187,12 @@ public final class SenderPool implements AutoCloseable {
     // the pool's capacity instead of ratcheting it down until process exit.
     // Out-of-range startup recoverers are NEVER added: they carry no
     // leakedSlots tick and their index has no slotInUse entry to free.
-    // Guarded by lock.
-    private final ArrayList<SenderSlot> retiredSlots = new ArrayList<>();
+    // Pre-sized to maxSize (every entry keeps a distinct in-range slot index
+    // reserved, so size can never exceed maxSize): add() never grows the
+    // backing array, so a retire (leakedSlots++ then add, under lock) cannot
+    // fail on allocation and strand a counted-but-untracked slot that
+    // reprobeRetiredSlots() could never recover. Guarded by lock.
+    private final ArrayList<SenderSlot> retiredSlots;
     // SF slots currently held by the in-range startup-recovery pass
     // (recoverOneSlotStep): each is reserved under `lock` for the
     // duration of its drain and counted in the borrow() cap check so a
@@ -306,6 +310,7 @@ public SenderPool(
         this.maxLifetimeMillis = maxLifetimeMillis;
         this.all = new ArrayList<>(maxSize);
         this.available = new ArrayDeque<>(maxSize);
+        this.retiredSlots = new ArrayList<>(maxSize);
         this.slotReleased = lock.newCondition();
         // Probe the config once, up front: this validates it eagerly (so a
         // bad config fails at construction even when minSize == 0) and tells
@@ -793,16 +798,24 @@ public PooledSender borrow() {
                     created.bumpGeneration();
                     return new PooledSender(created, created.generation());
                 }
+                // Capacity-starved: re-probe retired slots BEFORE the terminal
+                // timeout check — a deferred engine cleanup may have released a
+                // flock since the retire, and the freed index can admit a
+                // creation right now. The release itself never signals
+                // slotReleased (it happens in the delegate on a worker/I/O-thread
+                // exit path, volatile writes only), so this poll is the only way
+                // a borrower learns of it. Ordering matters twice over: a
+                // zero-timeout (try-once) borrow must get its one probe before
+                // throwing, and a borrower whose awaitNanos budget just expired
+                // must get a final probe on its wake-up pass instead of timing
+                // out on capacity that has already come back.
+                if (reprobeRetiredSlots()) {
+                    continue;
+                }
                 if (remainingNanos <= 0) {
                     throw new LineSenderException(
                             "timed out waiting for a Sender from the pool after " + acquireTimeoutMillis + "ms");
                 }
-                // Capacity-starved: before parking, re-probe retired slots — a
-                // deferred engine cleanup may have released a flock since the
-                // retire, and the freed index can admit a creation right now.
-                if (reprobeRetiredSlots()) {
-                    continue;
-                }
                 try {
                     remainingNanos = slotReleased.awaitNanos(remainingNanos);
                 } catch (InterruptedException e) {