test(poa): use PING readiness probe for redis test server startup

`wait_for_redis_ready` was checking only TCP connectability, which
succeeds as soon as redis-server's listener binds — before the
process is ready to handle commands. On a cold start this is fast
enough to mask, but the restart-and-lose-data test
(`unreconciled_blocks__when_redis_node_restarts_and_loses_data__drops_block_below_quorum`)
hit the gap consistently enough to flake locally and in CI:
adapter_b's first command on the restarted node would fail because
redis was still warming up.

Same class of half-ready issue as the 2026-04-22 mainnet hang —
TCP accept doesn't imply protocol readiness. Replace the TCP probe
with a real PING/PONG round-trip so we only return once redis is
actually serving commands.

Stress: previously flaky test now passes 20/20 in isolation and
the full leader_lock suite passes 5/5.

Author: Voxelot

crates/fuel-core/src/service/adapters/consensus_module/poa.rs

@@ -1650,7 +1650,6 @@ mod tests {
         net::{
             SocketAddrV4,
             TcpListener,
-            TcpStream,
         },
         process::{
             Child,
@@ -3406,12 +3405,22 @@ mod tests {
             .expect("Failed to spawn redis-server")
     }
 
+    /// Probe redis with a real `PING`/`PONG` round-trip — TCP accept can
+    /// succeed before redis-server is ready to process commands (the
+    /// same class of half-ready state that caused the 2026-04-22
+    /// mainnet hang). On a fresh start this is usually instant; on
+    /// restart it can take a few extra ticks while redis re-binds.
     fn wait_for_redis_ready(port: u16) {
-        let addr = SocketAddrV4::new(std::net::Ipv4Addr::LOCALHOST, port);
+        let url = format!("redis://127.0.0.1:{port}/");
         let start = std::time::Instant::now();
         let timeout = Duration::from_secs(5);
+        let per_attempt = Duration::from_millis(200);
         while start.elapsed() < timeout {
-            if TcpStream::connect(addr).is_ok() {
+            if let Ok(client) = redis::Client::open(url.as_str())
+                && let Ok(mut conn) = client.get_connection_with_timeout(per_attempt)
+                && let Ok(reply) = redis::cmd("PING").query::<String>(&mut conn)
+                && reply == "PONG"
+            {
                 return;
             }
             thread::sleep(Duration::from_millis(10));