test(qwp): allocate distinct ports atomically in the all-unreachable walk test

CI (linux-x64, build 247632) failed QwpQueryClientWalkTrackerTest.
testWalk_AllUnreachableThrowsHttpClientException with
IllegalArgumentException: "duplicate addr entry: localhost:39695".

Root cause: the test picked its two unreachable ports with two
back-to-back TestPorts.findUnusedPort() calls. That helper is
bind-close-return -- once its probe ServerSocket closes, the port goes
back to the kernel's ephemeral pool, and Linux readily hands the
just-released port to the next bind(0). Both calls returned the same
port, the config became addr=localhost:P,localhost:P, and ConfigView's
duplicate-addr validation (84da57d, pre-existing on main) rejected it
before the endpoint walk under test ever ran. Latent flake since the
test was written; unrelated to this PR's changes.

Fix: TestPorts.findUnusedPorts(n) holds all n probe sockets open
simultaneously, forcing the kernel to issue n distinct ports, and
closes them together. The walk test uses findUnusedPorts(2). This is
the only call site combining independently-picked ports into one
config (verified: other multi-call tests use one port per config).

Author: bluestreak01

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/QwpQueryClientWalkTrackerTest.java

@@ -170,10 +170,14 @@ public void testWalk_AllUnreachableThrowsHttpClientException() {
         // The exception type is HttpClientException (transport-only
         // failure mode) -- distinct from QwpRoleMismatchException which
         // would falsely suggest a topology issue.
-        int port1 = TestPorts.findUnusedPort();
-        int port2 = TestPorts.findUnusedPort();
+        // findUnusedPorts (plural) holds both probe sockets open at once so
+        // the two ports are guaranteed distinct — two separate
+        // findUnusedPort() calls can return the SAME port (bind-close-return
+        // lets the kernel recycle it immediately), which fails the config's
+        // duplicate-addr validation before the walk under test even runs.
+        int[] ports = TestPorts.findUnusedPorts(2);
         try (QwpQueryClient client = QwpQueryClient.fromConfig(
-                "ws::addr=localhost:" + port1 + ",localhost:" + port2 + ";auth_timeout_ms=300;")) {
+                "ws::addr=localhost:" + ports[0] + ",localhost:" + ports[1] + ";auth_timeout_ms=300;")) {
             try {
                 client.connect();
                 Assert.fail("expected HttpClientException on unreachable hosts");

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/TestPorts.java

@@ -40,4 +40,44 @@ public static int findUnusedPort() {
             throw new RuntimeException("failed to allocate an ephemeral port", e);
         }
     }
+
+    /**
+     * Allocates {@code n} DISTINCT ephemeral ports. All {@code n} probe
+     * sockets are held open simultaneously, so the kernel is forced to hand
+     * out {@code n} different ports; they are closed together only after
+     * every port has been collected.
+     * <p>
+     * Do NOT emulate this with repeated {@link #findUnusedPort()} calls:
+     * that helper is bind-close-return, and once its probe socket closes the
+     * port returns to the kernel's ephemeral pool — Linux readily hands the
+     * just-released port straight back to the next {@code bind(0)}, so two
+     * back-to-back calls can return the SAME port. That exact race made a
+     * multi-addr config fail validation with "duplicate addr entry" in CI.
+     */
+    public static int[] findUnusedPorts(int n) {
+        if (n <= 0) {
+            throw new IllegalArgumentException("n must be > 0: " + n);
+        }
+        ServerSocket[] sockets = new ServerSocket[n];
+        int[] ports = new int[n];
+        try {
+            for (int i = 0; i < n; i++) {
+                sockets[i] = new ServerSocket(0, 50, InetAddress.getLoopbackAddress());
+                ports[i] = sockets[i].getLocalPort();
+            }
+            return ports;
+        } catch (IOException e) {
+            throw new RuntimeException("failed to allocate " + n + " ephemeral ports", e);
+        } finally {
+            for (ServerSocket s : sockets) {
+                if (s != null) {
+                    try {
+                        s.close();
+                    } catch (IOException ignored) {
+                        // best-effort; the probe socket carries no state
+                    }
+                }
+            }
+        }
+    }
 }