Eleven new accessor functions for the built-in Json ADT, shipped as
pure-Vera prelude functions rather than WASM translators.  Closes #366.

Layer 1 - type-coercion accessors (Json -> Option<T>):
- json_as_string, json_as_number, json_as_bool, json_as_int,
  json_as_array, json_as_object
- Some when the Json's constructor matches the target type, None
  otherwise.  Accessors are disjoint: at most one returns Some.

Layer 2 - compound field accessors (Json, String -> Option<T>):
- json_get_string, json_get_number, json_get_bool, json_get_int,
  json_get_array
- Each collapses json_get(obj, key) + json_as_X into one call;
  missing field OR wrong-typed field both return None.  The pattern
  ~90% of real API-consuming code wants.

json_as_int specifically:
- Calls float_to_int, which truncates toward zero.
- Guards against the float_to_int trap on NaN and infinity via
  float_is_nan / float_is_infinite, returning None for those inputs.

Implementation - first non-WASM-translator stdlib addition this
stage:
- All 11 bodies live in vera/prelude.py _JSON_COMBINATORS as match
  expressions over Json; the compiler already injects the prelude
  into every module that references Json values.  No new host
  imports, no new WASM emit.
- vera/environment.py registers the 11 new FunctionInfo entries
  alongside existing json_get / json_type registrations.
- vera/prelude.py extended in three places: combinator bodies,
  _source_mentions_json detection set, and the injection-site
  shadow-check set.

Tests and example:
- 19 new unit tests (TestJsonTypedAccessors in test_codegen.py) -
  every accessor, matching and mismatched constructors, hit and
  missing field, wrong type, NaN/infinity guards, disjointness
  invariant.
- 2 new browser parity tests (TestBrowserJsonAccessors) - exhaustive
  Layer-1 + Layer-2 sweeps under wasmtime and Node.js.
- New conformance ch09_json_accessors.vera with 15 test functions
  (level: run).
- examples/json.vera rewritten to use the accessors; eliminates the
  per-field two-level match boilerplate.

Docs swept:
- spec/09-standard-library.md: new section 9.6.23.
- SKILL.md: new 'Typed accessors (Layer 1 and Layer 2)' subsection
  in the Json section plus naming-convention bump.
- CHANGELOG, HISTORY (Stage 11 table row), ROADMAP (#366 removed
  from short-term queue and Phase 4c, replaced with #475 bug
  cleanup as the new top priority).
- Count bumps across TESTING/CLAUDE/AGENTS/FAQ/README/vera-README.

Co-Authored-By: Claude <noreply@anthropic.invalid>

Verified each finding against the current code; fixed all five.

Real fixes:
- HISTORY.md: the v0.0.119 row was listed before v0.0.118 in the
  Stage 11 release table.  Convention is oldest-to-newest; swapped
  them.  Also fixed a spurious duplicate of line 255 introduced by
  the awk swap.
- scripts/check_skill_examples.py: the ALLOWLIST dict had two
  duplicate numeric keys (1845 at lines 121 and 124; 1893 at
  lines 126 and 138) that silently shadowed two of the four real
  entries via last-write-wins.  Four code blocks at four distinct
  line numbers (1845, 1878, 1893, 1926) now each have their own
  explicit entry; my earlier #366 additions used 1878 and 1926 as
  separate entries, so folded those into the main Import / Map-Set
  sections.  Added an AST-based duplicate-key check during CR-fix
  verification (AnnAssign-aware because the ALLOWLIST is type-
  annotated now).
- vera/prelude.py json_as_int: extended the float-to-int trap guard
  to cover finite overflow (|f| >= 2^63), not just NaN/infinity.
  Now returns None for all four WASM trap paths.  Previously
  returned `None` for NaN/infinity but would still trap on finite
  out-of-range values — documented but arguably surprising for
  an accessor.  One extra `||` pair in the guard expression.

Test coverage additions:
- tests/test_browser.py test_layer1_coercions: extended with +inf,
  -inf, json_as_array matching JArray, and json_as_object matching
  a parsed JObject (via json_parse to get a real Map).
- tests/test_browser.py test_layer2_compound_accessors: extended
  with a non-object (JArray) Json across all five Layer-2
  accessors to assert they return None (underlying json_get returns
  None for non-JObject; the accessor chain preserves that).
- tests/test_codegen.py: added test_json_as_int_finite_overflow_
  returns_none (|f| = 2^63) and
  test_json_as_int_finite_negative_overflow_returns_none (|f| = 2^64).
  Both required the finite-overflow guard above.
- tests/test_codegen.py: new "Import gating" section with three
  tests — two pin the invariant that json_as_* / json_get_*
  accessors do NOT force `(import "vera" "json_parse")` or
  `(import "vera" "json_stringify")` emissions (grep the WAT for
  the import-table entry); one complementary test uses json_parse
  and asserts the import DOES appear, pinning the check's
  direction.

Doc updates reflecting the finite-overflow guard:
- CHANGELOG, HISTORY, spec/09 §9.6.23 sentence, SKILL.md
  one-liner comment all updated to "every float_to_int trap path"
  or equivalent phrasing; the old wording ("NaN and infinity")
  was now incomplete.

All 3,518 tests pass; mypy clean; all 14 doc validation scripts
green.

Co-Authored-By: Claude <noreply@anthropic.invalid>

Verified each finding; fixed all six.  One uncovered a pre-existing
bug (already tracked in #475 bug 9) during browser-parity testing
and required a workaround.

Real fixes:
- HISTORY.md: the literal `|f|` in the v0.0.119 row was being
  parsed as extra table separators (same bug as the `||` issue on
  the v0.0.118 row last week).  Wrapped `|f| >= 2^63` in backticks.
- scripts/check_skill_examples.py: the comment block above the
  Import allowlist entries had a misleading parenthetical
  referring to only two line numbers.  Rewrote to state the four
  distinct numbers explicitly and reference the #511 fix.
- spec/09-standard-library.md §9.6.23: "No new host imports; no
  new WASM emit" was too terse and technically wrong — the
  accessors ARE compiled to ordinary WASM functions when
  referenced.  Rewrote to clarify "no new host imports and no
  dedicated WASM translator paths" while noting the accessors
  still compile as regular WASM when used; modules that never
  call any of them pay zero WASM cost.
- tests/test_browser.py test_layer1_coercions: extended the
  json_as_int sweep to cover the finite-overflow cases (|f| =
  2^63 upper, -2^63 lower boundary, below -2^63), with an
  explicit note that the upper bound is exclusive but the lower
  bound is inclusive (matching WASM's i64 range).
- tests/test_codegen.py: added test_json_as_int_boundary_minus_2_63
  _is_representable (pins Some(INT64_MIN) at the inclusive lower
  bound — a strict-vs-non-strict comparison off-by-one would
  silently corrupt valid inputs) and test_json_as_int_boundary_
  just_below_minus_2_63 (pins None at the next representable
  Float64 below -2^63).  The first failing attempt used
  -2^63 - 1024, which is exactly halfway between representable
  doubles and rounds back to -2^63 — now using -2^63 - 2048,
  the true ulp-below value.  Docstring of TestJsonTypedAccessors
  updated to document all four guarded trap paths.

Pre-existing bug surfaced:
- The browser -2^63 test initially printed the value via
  int_to_string(@Int.0).  Browser runtime returned `-` instead of
  `-9223372036854775808` — this is #475 bug 9 (_translate_to_string
  INT64_MIN negation overflow), which predates this PR.  Worked
  around with `bool_to_string(@Int.0 < 0)` which probes the value
  without triggering the bug.  Note added to the test body.  The
  bug itself is on the queue as part of the upcoming v0.0.120
  #475 cleanup.

All 3,520 tests pass; mypy clean; all 14 doc validation scripts
green.

Co-Authored-By: Claude <noreply@anthropic.invalid>

Verified each finding; fixed three; dismissed one as contradicting
established table format.

Real fixes:
- TESTING.md line 85: "collection of 79 small" was stale; bumped
  to 80 to match the header "80 programs across 9 spec chapters"
  two lines above.  One of the conformance-count references that
  slipped through the earlier count-sync sweep.
- spec/09-standard-library.md §9.6.23: the boundary wording for
  json_as_int was imprecise.  Rewrote to state the exact i64 range
  ([-2^63, 2^63) — closed-open), explain the asymmetry (two's
  complement can represent INT64_MIN = -2^63 but not +2^63), and
  add an explicit note that json_as_int(JNumber(-2^63)) correctly
  returns Some(INT64_MIN).  The "|f| >= 2^63" phrasing was
  technically wrong — it conflated f = -2^63 (representable) with
  f = +2^63 (not).
- tests/test_codegen.py test_json_as_int_boundary_minus_2_63_is_
  representable: previously only asserted Some(_), which failed to
  pin the observed value at INT64_MIN.  Added two indirect probes
  that sidestep #475 bug 9 (int_to_string(INT64_MIN) negation
  overflow):
    (a) @Int.0 < 0 holds (bool_to_string -> "true");
    (b) @Int.0 + 1 = INT64_MIN + 1 = -9223372036854775807, which IS
        serialisable without hitting the bug.
  Assertion now: _run_io(src) == "true,-9223372036854775807".  Any
  silent truncation or off-by-one guard would fail at least one
  probe.  Mirror probe applied to the browser test in the same
  class.

Dismissed:
- HISTORY.md line 256: CR claimed the row should be a "single
  concise closeout line" per "the project closeout format".  That
  claim doesn't match the actual format — every Stage 11 entry
  (v0.0.112 through v0.0.118) is a detailed paragraph describing
  what shipped, what was learned, and what's deferred.  My v0.0.119
  entry matches this established convention.  Shortening it would
  break consistency, not restore it.  No change.

All 3,520 tests pass; mypy clean; all 14 doc validation scripts
green.

Co-Authored-By: Claude <noreply@anthropic.invalid>

Trim Stage 10 + 11 HISTORY rows to match early-stage format:
- The table format established in Stage 1 is one to two sentences
  per row (headline + key details).  Stage 10 and 11 entries had
  drifted into essay-length paragraphs (some 240+ words).  Shortened
  every Stage 10 and Stage 11 row to the early-stage shape —
  headline (bolded feature / issue link), one sentence of detail,
  optional reference to tracking issues.  Detailed narrative stays
  in the stage-intro paragraphs, CHANGELOG, and the GitHub release.
- Net diff across the two stages: ~2,000 words → ~600 words.
- v0.0.119 row stays at its earlier shortening.
- #512 filed to track the convention going forward (brief
  summary in HISTORY; the essay in CHANGELOG).

Two new CR findings addressed:
- tests/test_codegen.py TestJsonTypedAccessors docstring: the
  "finite overflow (|f| >= 2^63)" phrasing conflated -2^63
  (representable as INT64_MIN) with +2^63 (not representable).
  Rewrote to state the exact closed-open i64 range ([-2^63, 2^63))
  and the precise trap condition (f >= 2^63 or f < -2^63).
- tests/test_codegen.py test_json_as_int_infinity_returns_none:
  previously only exercised +infinity.  Extended to cover both
  signs — both are distinct trap inputs from finite-overflow and
  both are caught by float_is_infinite (sign-agnostic).  Browser
  parity test already covered both ±inf.

All 3,520 tests pass; mypy clean; all 14 doc validation scripts
green.

Co-Authored-By: Claude <noreply@anthropic.invalid>