feat(data): db.observe.derive + Database.Read read projection

[krisnye]

Auto-tracking reactive derivation for the ECS. db.observe.derive(compute) runs compute against a read-only projection of the database, records exactly the reads it performs, and re-emits only when a recorded dependency changes — so the whole class of "read a field but forgot to subscribe to it" staleness bugs (e.g. the frameRate gap found in the FFP avTimelinePayload refactor) becomes impossible by construction.

Still a review PR — no version bump; not necessarily merging as-is.

Database.Read<DB>

The read-only projection the compute callback receives. Keeps get / read / select, resources, index lookups (find / findRange / get), and archetype identity (components / id). Structurally omits observe (a derive subscribes for you), transactions/writes, queryArchetypes, locate, and per-archetype columns / rowCount / insert. Misuse is a compile error, not a runtime throw. Supporting type Database.Index.ReadHandle<C,I> = a handle minus observe.

read overloads

• read(entity, archetype) narrowed to Readonly<T> (was Readonly<T> & EntityReadValues<C>); minArchetype → archetype. Blast radius across adobe/data: zero — no caller was leaning on the whole-entity union.
• new read(entity, components[]) — a projection (present-or-undefined; null only when the entity is absent). Names the exact fields touched so a derive can scope its dependencies to them.

derive engine (observe-derive.ts)

• One read-recording wrapper per database, shared across all derives; its recorded-dep set is reset per synchronous compute run. Safe to share because compute is synchronous and the read surface exposes no writes/observers/nested-derives, so runs can't overlap or recurse. (No Proxy — the read surface is a finite, explicit wrapper.)
• Dependencies reduce to two kinds, both resolved from the transaction result:
  • entity deps — get / read(entity, archetype|components[]) → recompute when that entity is in changedEntities and (for scoped reads) a watched component changed on it, or it was deleted;
  • column deps — select include/exclude/where/order, an index's readColumns, and resource names → recompute when the transaction's changedComponents intersects them.
• One transaction subscription per derive; recompute coalesced on a microtask; emit gated by structural equals (no re-emit on an equal result).
• Component-scoped granularity is opt-in via which read you call: read(e) = whole-entity dep, read(e, ["a"]) / get(e,"a") = just those fields.

Tests

• observe-derive.test.ts: initial synchronous emit; re-emit on a read component; no re-emit on an unread component (projection scoping) vs whole-entity coarseness; structural dedupe; select membership, index-bucket, and resource deps; coalescing; disposal.
• database-read.type-test.ts: positive read surface + @ts-expect-error for every omitted API (an unused expect-error fails tsc, so these prove each footgun is blocked).
• typecheck + lint + 911 ecs/observe tests green.

Notes / follow-ups

• Per-commit cost is O(Σ recorded deps across live derives) — the intended fine-grained trade.
• A no-op update records the entity in changedEntities, so it triggers a recompute that structural dedupe then suppresses (correct, mildly wasteful).
• Indexes/resources added by a later extend aren't in the shared recorder (built lazily on first use); fine for the create-time plugin case, a follow-up for dynamic extends.