fix(tests): wait for active connection count to reach expected value in ConnectionPoolReconnectsTest

box.stat.net().CONNECTIONS.current is updated asynchronously by the IProto
worker and closing the administrative net.box connection used by
executeCommandDecoded is asynchronous on the server, so a single read can
briefly observe a stale or transitional value. This made the absolute
assertion `assertEquals(count1, getActiveConnectionsCount(tt))` flaky when
timings shifted (e.g. under docker emulation locally and on the self-hosted
3.5.0 runner), producing `expected: <11> but was: <12>`.

Add a waitForActiveConnections(tt, expected) helper in BasePoolTest that
retries the assertion via the existing waitFor() loop, and use it in
ConnectionPoolReconnectsTest#testReconnectAfterNodeFailure at both
assertion sites (initial connect and post-reconnect). Other tests
(ConnectionPoolTest, ConnectionPoolHeartbeatTest) are unaffected as they
use the established baseline+delta pattern or pass in CI.

Verified locally on 3.5.0:
  - ConnectionPoolReconnectsTest: 10/10 PASS (previously flaky)
  - Full box-integration target modules: 0 failures

Author: opencode

tarantool-pooling/src/test/java/io/tarantool/pool/integration/BasePoolTest.java

@@ -15,6 +15,7 @@
 import java.util.concurrent.CompletionException;
 import java.util.concurrent.ThreadLocalRandom;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 import io.micrometer.core.instrument.Counter;
@@ -117,6 +118,28 @@ protected int getActiveConnectionsCountDelta(TarantoolContainer<?> tt, int basel
     return getActiveConnectionsCount(tt) - baseline;
   }
 
+  /**
+   * Asserts that the active connection count on the given Tarantool container reaches {@code
+   * expected}, retrying until it does. The IProto worker updates {@code
+   * box.stat.net().CONNECTIONS.current} asynchronously, and closing administrative connections
+   * (e.g. the {@code net.box} connection used by {@code executeCommandDecoded}) is asynchronous on
+   * the server, so a single read can briefly observe a stale or transitional value. Retrying the
+   * assert lets the worker converge on the final value.
+   *
+   * @param tt the Tarantool container under test
+   * @param expected the expected number of active connections
+   */
+  protected void waitForActiveConnections(TarantoolContainer<?> tt, int expected) {
+    try {
+      waitFor(
+          "Active connections count never reached " + expected,
+          Duration.ofSeconds(10),
+          () -> assertEquals(expected, getActiveConnectionsCount(tt)));
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   protected MeterRegistry createMetricsRegistry() {
     MeterRegistry metricsRegistry = new SimpleMeterRegistry();
     LongTaskTimer.builder("request.timer")

tarantool-pooling/src/test/java/io/tarantool/pool/integration/ConnectionPoolReconnectsTest.java

@@ -77,7 +77,7 @@ public void testReconnectAfterNodeFailure() throws Exception {
     assertTrue(pool.hasAvailableClients());
     List<IProtoClient> clients = getConnects(pool, "node-a", count1);
     assertTrue(pingClients(clients));
-    assertEquals(count1, getActiveConnectionsCount(tt));
+    waitForActiveConnections(tt, count1);
 
     tt.stop();
     Thread.sleep(1000);
@@ -110,7 +110,7 @@ public void testReconnectAfterNodeFailure() throws Exception {
         });
 
     assertTrue(pingClients(clients));
-    assertEquals(count1, getActiveConnectionsCount(tt));
+    waitForActiveConnections(tt, count1);
 
     assertEquals(count1, metricsRegistry.get("pool.size").gauge().value());
     assertEquals(count1, metricsRegistry.get("pool.available").gauge().value());