feat(engine): serde foundation + amend C16 dependency policy (cycle D / iter 1)

Iteration 1 of the run-registry cycle (#33): lay the dependency + serde
foundation the registry's typed read-path needs, and amend the contract that
forbade it.

Contract change (load-bearing — C18/C16). C16's blanket "zero-external-
dependency by commitment" + "aura-ingest is the sole external-dependency
firewall" framing is struck and replaced by a considered, per-case dependency
policy: dependencies are admitted by deliberate review (what a crate pulls in
vs. what it buys), with particular scrutiny for anything entering the frozen
deploy artifact (C13); standard vetted crates (serde, rayon, ...) pass that
review and are used wherever they do the job, including in the bot; hand-rolling
what a vetted crate does is the anti-pattern. C16's engine/project split +
three-tier node reuse are unchanged. The five source comments that asserted the
struck framing (aura-engine/aura-ingest Cargo.toml + aura-ingest/report.rs docs)
are rewritten to match; no live source or ledger text still asserts it.

Per-case justification for serde (the policy now requires one): it gives the
run-report types a typed (de)serialization path — exactly what ranking/compare
over stored runs needs, and what the writer-only hand-rolled JSON (C14) could
never provide; closes the typed-read-path gap (#17). Its closure is tiny,
ubiquitous, heavily audited, and its output deterministic (C1-safe). serde_json
is test-only this iteration (dev-dependency); no production serde_json yet.

Changes: [workspace.dependencies] serde (derive) + serde_json; serde derives on
Timestamp (aura-core) and RunMetrics/RunManifest/RunReport (aura-engine), with
serde_json round-trip tests (window renders as a [from,to] integer array via the
transparent Timestamp newtype). The hand-rolled to_json writers are untouched
(still drive stdout). No aura-registry crate, no SweepPoint change — those are
iterations 2 and 3.

Verified: cargo test --workspace green (incl. the two new round-trip tests);
clippy --workspace --all-targets -D warnings clean; no surviving assertion of
the struck zero-dep framing in live source or the ledger.

refs #33

docs/design/INDEX.md

@@ -548,18 +548,23 @@ chosen strategy + broker freeze into a standalone binary. **A project is
 therefore always a Rust program built on the engine.** Beyond the node-reuse
 tiers, the engine workspace also carries non-node crates — `aura-engine` (the
 run loop), `aura-cli` (the `aura` binary), and **`aura-ingest`** (the
-data-source ingestion edge, cycle 0011). `aura-ingest` is the
-**external-dependency firewall**: it alone links external crates (via
-`data-server`), keeping the other engine crates and the frozen deploy artifact
-(C13) dependency-pure (see External components). The engine workspace is
-**zero-external-dependency** by commitment — the hand-rolled JSON of C14/C18 and
-the from-scratch `aura-core` substrate exist precisely to honour it; the one
-sanctioned external tree enters at the ingestion edge and is firewalled there.
+data-source ingestion edge, cycle 0011, where the `data-server` external tree
+enters). **Dependency policy (amended 2026-06-10, cycle 0029).** Dependencies
+are admitted by deliberate, **per-case review** — what a crate pulls in weighed
+against what it buys — with **particular scrutiny for anything that enters the
+frozen deploy artifact** (C13: this bot = this commit). Well-established
+standard crates (`serde`, `rayon`, …) pass that review and are used wherever
+they do the job, including in the bot. There is **no blanket zero-dependency
+commitment** and **no blanket admission**; hand-rolling what a vetted standard
+crate already does is the anti-pattern, not the dependency. This strikes the
+original *"zero-external-dependency by commitment"* clause and the
+*"`aura-ingest` is the sole external-dependency firewall"* framing; `aura-ingest`
+remains the data-source ingestion edge, no longer a dependency wall.
 **Forbids.** Project-specific signals in the aura repo (it keeps at most
 example/fixture nodes under `examples/` for its own tests); a multi-project
 manager inside aura; a bespoke node registry/marketplace (cargo + Gitea *is* the
-package mechanism); an external (crates.io / git) dependency in any engine crate
-other than the ingestion-edge crate `aura-ingest`.
+package mechanism). (Dependency admission is governed by the per-case policy
+above, not a blanket ban.)
 **Why.** The engine/game split keeps the engine sharp and reusable while each
 project versions its own research with its own forward-queue. Promotion
 (local → shared → std) is the ordinary Rust reuse gradient, no new mechanism.