perf(blob-cache,db): release index mutex before disk I/O; skip per-acquire DB ping

CachedBlobBackend held its single tokio::Mutex<LruCache> across filesystem
syscalls, serializing every concurrent cache operation behind one lock:
- get_blob_stream / get_blob_range_stream: held across File::open()/seek()
- delete_blob: held across remove_file()
- initialize: held across the full cache-dir walk
- eviction (insert + fetch paths): held across remove_file() loops

Now the lock only guards the in-memory LRU. Presence checks bump recency
and release the guard before touching the filesystem (a vanished file falls
through to the existing fetch-and-cache path, covering the race), and
eviction selects victims under the lock then unlinks them after releasing
it. The duplicated eviction loop is extracted into
CachedRef::collect_evictions.

db: set test_before_acquire(false). With warm min_connections and a bounded
max_lifetime, the liveness ping sqlx issues on every acquire() costs more
than the rare dead connection it catches; stale sockets surface as a query
error and the pool recycles them either way.

https://claude.ai/code/session_01UtfkS3nZF1vrF5jNAps6wV

src/infrastructure/db.rs

@@ -114,6 +114,12 @@ async fn create_pool_with_retries(
             .acquire_timeout(Duration::from_secs(connect_timeout_secs))
             .idle_timeout(Duration::from_secs(idle_timeout_secs))
             .max_lifetime(Duration::from_secs(max_lifetime_secs))
+            // Skip the liveness ping sqlx issues on every acquire() (on by
+            // default): with warm min_connections and a bounded max_lifetime,
+            // that extra round-trip per checkout costs more than the rare dead
+            // connection it catches. A stale socket surfaces as a query error
+            // and the pool recycles it either way.
+            .test_before_acquire(false)
             .connect(connection_string)
             .await
         {