perf: optimize Tablet memory layout and per-query lookup speed

[mykaul]

Summary

Five incremental optimizations to the tablets hot path, each in a separate commit:

1. __slots__ on Tablet — eliminates per-instance __dict__ allocation
2. tuple replicas — replicas are immutable after creation; use tuple instead of list
3. Cached _replica_dict — build {host_id: shard_id} dict once at construction, use it in both per-query hot paths (policies.py and pool.py). Also fixes a latent iterator-consumption bug where passing a generator to Tablet() would silently produce an empty _replica_dict.
4. Streamline from_row — inline the _is_valid_tablet check to eliminate a staticmethod descriptor lookup, an extra function call, and a redundant is not None guard
5. Parallel token index lists — maintain _first_tokens and _last_tokens as plain list[int] dicts alongside _tablets, so bisect_left runs entirely in C on native ints instead of calling an attrgetter callback per comparison. Follow-up to PR perf: use stdlib bisect and attrgetter in tablets.py (100's of ns, 1.5-5.6x speedup) #757 which identified this opportunity in its own benchmarks.

Benchmarks (Python 3.14, best-of-5 rounds)

Memory per Tablet (deep, pympler.asizeof, 3 replicas)

State	Deep size	Change vs baseline
Baseline (no __slots__, list, no dict)	1856 B	—
After commit 1 (__slots__)	1400 B	-456 B
After commit 2 (tuple)	1384 B	-472 B
After commit 3 (_replica_dict)	1616 B	-240 B

Commits 1+2 save 472 bytes/tablet. Commit 3 spends 232 bytes back on the _replica_dict cache. Net: 240 bytes saved per tablet (13%). Commit 5 adds 16 bytes/tablet (two ints in parallel lists) — negligible.

Shallow breakdown (sys.getsizeof)

Component	Before	After	Change
instance shell	48 B	64 B	+16 B (slots have fixed overhead)
__dict__	296 B	0 B	-296 B
replicas container	88 B (list)	72 B (tuple)	-16 B
_replica_dict (3 entries)	—	224 B	+224 B

get_tablet_for_key (hit — the primary per-query hot path)

Tablets	Before	After	Saved	Speedup
10	293 ns	216 ns	78 ns	1.36x
100	351 ns	233 ns	118 ns	1.51x
1,000	448 ns	267 ns	181 ns	1.68x
10,000	537 ns	282 ns	255 ns	1.90x

Miss path (N=1000): 458 ns -> 229 ns (2.0x).

Other per-query hot paths

Path	Before	After	Speedup
policies.py: set(map(lambda r: r[0], tablet.replicas))	372 ns	18 ns (tablet._replica_dict)	20.7x
pool.py: linear scan for shard_id	199 ns	73 ns (dict.get)	2.7x
replica_contains_host_id	O(n) linear	O(1) dict in	—

Construction (Tablet.from_row)

State	Time	Change
Original (master)	143 ns	—
After commit 3 (_replica_dict + old from_row)	465 ns	+322 ns
After commit 4 (streamlined from_row)	410 ns	+267 ns

Commit 4 recovers ~54 ns (12%) of the construction regression. The remaining +267 ns vs master is the irreducible cost of building tuple() + dict() at construction time (~250 ns), which pays for itself on every query.

Tests

All 223 unit tests pass (tablets, policies, pool, metadata, cluster, response_future). 7 new tests added for _replica_dict behavior, including an iterator edge-case regression test.