Scale-out storage: sharded blob, in-memory and lookup stores; configured read replicas reported (ST-1 to ST-4, ST-16 to ST-30)

A Sharded blob store places each blob on xxh3(key) mod N, over the whole
key; reads fall back to the other members, so blobs placed under an
earlier member list stay readable, and deletes find them wherever they
are. The member list is recorded in the data store (secrets left out):
added or reordered members are a warning, a missing one refuses to open.
Blobs are compressed and marked before they reach a member. A Sharded
in-memory or lookup store sends each key to its home Redis member, and
prefix deletes and purges to all; a node whose member list differs from
the recorded one logs an error and runs on. Members are checked for
duplicates and must all open.

Until read-replica routing is built, each configured replica is reported
at startup instead of being silently ignored, and nothing connects to it.
The new scaleout_blob_tests covers tests 2 to 7, and the existing blob
suite passes against three FileSystem members (BLOB_STORE=Sharded).

crates/store/src/backend/postgres/main.rs

@@ -57,27 +57,16 @@ impl PostgresStore {
         .map_err(|e| format!("Failed to create connection pool: {e}"))?;
         let ts_configs = discover_ts_configs(&primary_pool).await;
 
-        let mut replicas = vec![];
+        // inbuxa: ST-2: replicas aren't used yet (the scale-out decision), so
+        // each one is reported rather than silently ignored
         for replica in config.read_replicas {
-            let mut cfg = cfg.clone();
-            cfg.dbname = replica.database.into();
-            cfg.host = replica.host.into();
-            cfg.user = replica.auth_username;
-            cfg.password = replica.auth_secret.secret().await?.map(|v| v.into_owned());
-            cfg.port = (replica.port as u16).into();
-            cfg.options = replica.options;
-            replicas.push(Store::PostgreSQL(Arc::new(PostgresStore {
-                conn_pool: if config.use_tls {
-                    cfg.create_pool(
-                        Some(Runtime::Tokio1),
-                        MakeRustlsConnect::new(rustls_client_config(config.allow_invalid_certs)?),
-                    )
-                } else {
-                    cfg.create_pool(Some(Runtime::Tokio1), NoTls)
-                }
-                .map_err(|e| format!("Failed to create connection pool: {e}"))?,
-                ts_configs: ts_configs.clone(),
-            })));
+            trc::event!(
+                Store(trc::StoreEvent::PostgresqlError),
+                Details = format!(
+                    "Read replica {}:{} {} isn't used yet: every operation goes to the primary",
+                    replica.host, replica.port, replica.database
+                ),
+            );
         }
 
         let primary = Store::PostgreSQL(Arc::new(PostgresStore {