perf(translate,turso): borrowed-key Arc cache + opt-in Turso handle reuse

[luthermonson]

What

Two independent perf changes to the translate cache and the experimental Turso backend.

1. TranslateCache: borrowed-key + shared Arc

Each dialect gets its own LRU keyed by a borrowed &str (Box<str> keys, Box<str>: Borrow<str>), returning a shared Arc<[TranslateResult]>. This removes, on every cache hit:

• the (Dialect, String) key allocation that a tuple key forced on each lookup, and
• the deep Vec<TranslateResult> clone handed to the caller.

Callers (litewire-session, litewire-postgres) now iterate the shared slice by reference; translate_cached returns the Arc.

Sharding was measured and dropped. An LRU get is a write (it promotes to MRU), so concurrent hits on a hot statement contend on that entry's list links regardless of how many locks guard the map — aggregate throughput did not improve — while the extra hash to select a shard cost more than the lookup, and dividing a fixed capacity across shards turned a skewed key distribution into thrashing.

translate-cache hit, single-thread hot key (release, median 9 × 2M)	ns/op
before — owned String key + Vec clone	69.8
after — borrowed &str key + Arc clone	23.8

2.93×.

2. litewire-turso: opt-in idle-connection reuse

TursoBuilder::handle_reuse(max_idle) (off by default). A clean connection is parked on drop and checked back out by a later session, keeping the engine's per-connection prepared-statement cache warm. A fresh Database::connect() opens with an empty statement cache, and the first prepare of each distinct statement on a cold connection is the dominant per-session cost — the whole prize is amortising it.

Hygiene is cheap per-statement dirty-tracking that gates parking, not an expensive checkout probe:

• A wire client's SET ... translates to a no-op, so the only way to change connection-scoped pragma state is a literal PRAGMA name = value — caught generically.
• CREATE TEMP/TEMPORARY (a sqlite_temp_master object) and ATTACH/DETACH are the remaining vectors.
• Open transactions are refused at park (is_autocommit, sync); last_insert_rowid is snapshot at checkout so a reused handle never reports the prior session's insert id (the engine has no setter).

Checkout is a free autocommit re-confirm — no queries.

An earlier design validated a PRAGMA-readback fingerprint at checkout (temp-count + N pragma reads). Measured 0.99× — no net win: the probe cost as much as the statement-cache saving. That result drove the redesign above.

turso session cycle: connect + 5 distinct first-queries + drop (file-backed, single-thread, median)	µs/cycle
reuse OFF (fresh connect, cold cache)	154.9
reuse ON (parked warm handle)	53.0

2.92×.

MySQL wire session: TCP + handshake + 5 SELECTs + close (end-to-end via mysql_async, median)	µs/session
reuse OFF	1460
reuse ON	1220

1.20× — reuse saves ~240 µs/session; the absolute is dominated by the per-session TCP + MySQL handshake, which reuse does not touch.

Adds ReuseStats + Turso::reuse_stats(). Reuse is ignored (with a warn!) when enable_cdc_on_connect is set.

Tests

Reset-behaviour tests for every leak vector: temp objects, pragma writes, open transactions, last_insert_rowid, plus staleness age-out, pool-capacity bound, and reuse-disabled-by-default. cargo test --workspace --all-features green (956); clippy -D warnings clean on default and --all-features; nightly fmt clean.

Notes

• No dependency or Cargo.toml changes. Turso backend remains experimental.
• Measurements are single-threaded medians (the reproducible lane; contended throughput swings run to run).