Add a Zones console: create and manage local zones, records and delegations

The console could not see local zones at all. `blocklist.local_zones` compiled
a store that nothing read back: there was no API for a zone, its records, its
delegations or the file a record came from, and no way to change one without
editing YAML and reloading. The Domains page is the blocklist's inline rules,
not local data, so nothing in the console covered the half of the server that
answers authoritatively from disk. There is now a Zones page and the endpoints
behind it: `GET /api/zones`, `POST`/`PUT`/`DELETE /api/zones/records`,
`POST`/`DELETE /api/zones/delegations` and `DELETE /api/zones?zone=`.

**The console owns one directory and nothing else.** `blocklist.managed_zones`
holds one `<apex>.zone` per zone, with that zone's SOA, apex NS set and the
records added there, and it is compiled by the same `localzone.Load` as the
operator's files — so a record added from the console is served on the next
query, with no reload and no restart. Files in `blocklist.local_zones` are
listed and shown read-only and are never rewritten; the key defaults to empty,
so a deployment that never sets it gets a zone browser and no zone writes.
Which file a record came from is now part of the store (`zone.files`, keyed by
the index the store already uses), so the snapshot can say "console" or "your
file" per record; the query path does not read it.

**The writer proves its own output.** A record is validated by the project's own
master-file parser, so `www` means `www.<zone>` and a bare CNAME target is
completed exactly as it would be in a zone file; the file is rendered, and the
rendering is re-parsed and compared with the records it meant to write before
the file is renamed into place. A writer bug that dropped a record would
otherwise present as a zone that silently stopped answering. A zone that cannot
answer is refused rather than created: no SOA means no NXDOMAIN or NODATA
authority, and no apex NS means nothing is delegated and no server is named. The
SOA's primary follows the apex NS set — a zone whose SOA names a server outside
its own NS set hands out a referral no resolver can follow — and the serial
moves on every write.

**A delegation takes the names under it, so a record below a cut is refused.**
The store answers those names as delegated without reading the zone file, which
would make the record data that looks alive and never answers. `DELETE
/api/zones?zone=` exists for the same reason from the other side: a zone the
console created is a real zone, so it says NXDOMAIN for what it does not hold,
and deleting a record is not what gives a name back to upstream. It is
refused for a zone that also has records outside the managed directory, because
removing that file would remove none of the zone.

**Two bugs the work turned up.** `engine.applyConfig` published local-record
metrics only when `blocklist.local_zones` was non-empty, so a zone the console
created was served but never counted; the gate is now the store's own record
count. And the record-value renderer fell back to `RR.String()` for every type
it did not know, which is the whole line rather than the RDATA — it wrote a
name and a TTL into the value column for DHCID, LOC, SSHFP and SVCB, and would
have fed that back as a record value on the next edit.

Every write recompiles the store and flushes the cache. Which names changed is
not knowable from the API, and a cached upstream answer for a name the zone now
answers is simply wrong, so the flush is blunt on purpose.

The wire shapes are type aliases in `internal/api` rather than copies, so there
is one set of json tags, and `TestZoneEndpointKeySets` pins the key set at every
level with a record and a delegation actually present — an empty list only
proves the envelope. `TestZoneWritesNeedAManagedDirectory` pins the read-only
default, and `TestZoneConsoleRoundTrip` walks the whole thing: a record added
through the API is answered authoritatively on the next query, a cut stops the
parent answering below it, and deleting the zone hands the name back.

Verified against a running instance built from this tree: records and
wildcards answer with `aa`, relative names are qualified, a record below a cut
is refused with a message that says why, and the file on disk is a zone file
an operator can read. The console page is typechecked and built; the browser was
not available in this round, so it has not been looked at.

AGENTS.md

@@ -55,6 +55,7 @@ Cache is a single shard-local lookup; only a miss touches the network.
 |---|---|---|
 | Scope | Full production | clustering, metrics, ACLs, query logs, hot reload, Docker, k8s, CI |
 | Config store | YAML + DNS master files | reviewable/diffable in git |
+| Console-written zone data | Its own directory, `blocklist.managed_zones`, one file per apex | the console is a real operator surface, so it needs somewhere to write; a separate directory keeps the operator's master files read-only to it, and an unset key keeps the console read-only by default |
 | Cluster sync | Valkey (Redis protocol) | simple, mature Go client, easy local dev |
 | Secure DNS | DoT + DoH, **no DNSSEC validation** | deliberately out of scope; AD/CD/extended-RCODE are passed through only |
 | Hot cache | Sharded LRU in memory, bbolt for snapshots | no I/O on the hot path; warm restart |
@@ -113,6 +114,18 @@ Break these and you break the design, not just the test.
 - **The Go heap does not account for goroutine stacks, runtime metadata, or the
   bbolt mmap.** `memory.reserve` exists to cover them; the cache snapshot and
   query log are mmapped and live outside the heap entirely.
+- **The zone writer proves its own output.** Every record is validated by the
+  project's own master-file parser, the file is rendered, and the rendering is
+  re-parsed and compared with the records it meant to write *before* the file
+  is renamed into place. A writer bug that lost a record would otherwise show
+  up as a zone that silently stopped answering.
+- **A zone the console creates is a real zone.** It is authoritative, so it
+  answers NXDOMAIN for the names it does not hold, and `DELETE /api/zones` is
+  the only thing that hands a name back to upstream. Deleting a record is not,
+  and the API never pretends it is.
+- **A delegation takes the names under it.** The store answers them as
+  delegated without reading the zone file, so a record at or below a cut is
+  refused rather than written as data that looks alive and never answers.
 - **Unknown config keys are silently ignored** (a settled decision, pinned by
   `TestLoadIgnoresUnknownKeys` in `internal/config`: `yaml`
   `KnownFields(true)` was considered and rejected as a behaviour change for