test(client): fix closeStarted race in closed-mid-creation lock-probe test

closedMidCreationTeardownRunsOutsideThePoolLock started the pool-closer
thread and the idempotent-re-close lock probe with nothing ordering their
entry into close(). On a slow scheduler (Windows CI, build 251972) the
probe won the closeStarted race, became the primary closer and
legitimately parked in the new bounded 5s in-flight-creation wait -- the
parked teardown deliberately holds inFlightCreations at 1 -- so
probe.join(5s) expired and the lock-free assertion failed even though
the pool lock was free the whole time.

Wait on the hasCreationWaiterForTesting() seam until the pool-closer has
claimed closeStarted and parked in the creation wait (releasing the
lock) before starting the probe, making the probe a true re-close. Also
swap the reflective markClosing() invoke for the markClosingForTesting()
seam. Reproduced by delaying the closer thread 400ms: the old test fails
with the exact CI assertion in 5.1s; the fixed test passes in 0.5s under
the same delay.

Author: bluestreak01

core/src/test/java/io/questdb/client/test/impl/SenderPoolCloseLifecycleTest.java

@@ -288,16 +288,29 @@ public void closedMidCreationTeardownRunsOutsideThePoolLock() throws Exception {
 
                 // Raise the same early shutdown signal used by QuestDBImpl so
                 // the creation deterministically takes the teardown branch.
-                Method markClosing = SenderPool.class.getDeclaredMethod("markClosing");
-                markClosing.setAccessible(true);
-                markClosing.invoke(pool);
+                pool.markClosingForTesting();
 
                 // close() now owns the in-flight creation reservation until
                 // its closed-mid-creation teardown completes, so run it on a
                 // separate thread while the creation remains parked.
                 Thread poolCloser = new Thread(pool::close, "pool-closer");
                 poolCloser.start();
 
+                // Make poolCloser the primary closer DETERMINISTICALLY before
+                // anything else moves: wait until it has claimed closeStarted
+                // and parked in the bounded in-flight-creation wait (which
+                // releases the lock). Without this the lock-probe close()
+                // below can win the closeStarted race, become the primary
+                // closer itself and legitimately block in that same 5s wait
+                // (the parked teardown holds inFlightCreations at 1) -- a
+                // false "lock held" failure under slow thread scheduling.
+                long closerParkedDeadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(10);
+                while (!pool.hasCreationWaiterForTesting()) {
+                    Assert.assertTrue("pool-closer never parked in the in-flight-creation wait",
+                            System.nanoTime() < closerParkedDeadline);
+                    Thread.sleep(1);
+                }
+
                 // Let the creation finish: the borrower re-locks, observes the
                 // closed pool and starts the delegate teardown, which parks.
                 releaseCreate.countDown();