feat(8.0): asOf at-gen vector defer — provider-served historical semantic search (#35)

A filtered semantic read at a historical generation (db.asOf(g).find({ query, where }))
no longer unconditionally rebuilds an ephemeral JS-HNSW over every at-g vector
(O(n@G), the OOM ceiling the 2026-06-24 scaling audit flagged). When the vector
index is a VersionedIndexProvider that advertises isGenerationVisible(g), Brainy:
  1. resolves the at-g metadata∩graph universe from the record-overlay path (no
     materialization — it's the metadata-only historical find),
  2. routes the vector leg to the provider with { allowedIds, generation }, and
  3. composes the at-g entities ranked by the provider's at-g vector distance.
Without a versioned provider (the JS index, or a native one that refuses the
generation) it falls through to the existing materialization — unchanged.

- Seam (A): VectorIndexProvider.search gains an optional `generation?: bigint`
  ("omitted = now"), the vector mirror of the graph provider's trailing-gen + the
  #46 allowedIds field. JsHnswVectorIndex accepts and ignores it (no per-gen
  segments → refuse/fall-back posture; Brainy never routes a historical read there).
- Gate: Db.find tries the native at-gen vector path before materialize(); host
  exposes canServeVectorAtGeneration + vectorSearchAtGeneration.
- generation is Brainy's u64 commit counter — the same value handed to the graph
  index on writes (graphWriteGeneration), so it maps 1:1 to the native side.

Decided lockstep with the cor team (handoff #35 thread: (A) + vector-only). The
gen-g candidate-vector supply for cor's exact-rerank (part-3) is a separate,
non-blocking seam still being confirmed; the honesty guard keeps this path inactive
(falls through to materialize) until cor's native at-gen rerank is live.

Tested: provider routing + at-gen universe correctness (excludes future-born,
applies the filter) + page window via a mock versioned provider; seam-ignore on the
JS index; 38 db-mvcc/db-temporal historical-read tests green (materialize fallback).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/plugin.ts

@@ -769,6 +769,19 @@ export interface VectorIndexProvider {
        * falls back to `filter`.
        */
       allowedIds?: OpaqueIdSet | ReadonlySet<string>
+      /**
+       * As-of generation for historical (time-travel) reads — the vector-side
+       * mirror of the {@link GraphAccelerationProvider} trailing `generation?`.
+       * Omitted = "now" (the live index). When set, a {@link VersionedIndexProvider}
+       * serves the kNN / exact-rerank over its retained at-`generation` segments
+       * instead of the current vectors, so `db.asOf(g)` semantic queries need no
+       * O(n@G) JS-HNSW rebuild. Brainy only passes it when the provider advertised
+       * `isGenerationVisible(generation)` at pin time; a provider that does not
+       * honor it MUST refuse/fall back (never score current vectors as if at-gen) —
+       * Brainy then serves the historical leg from its own materialization. Brainy's
+       * `generation` is the same u64 counter handed to the graph index on writes.
+       */
+      generation?: bigint
     }
   ): Promise<Array<[string, number]>>
   size(): number