autoindex: AST code extraction for 21 more languages (13 → 34) - #317

Motivation
----------
`xerj autoindex`'s tree-sitter registry covered 13 languages. Every other
source tree fell through to the PROSE extractor -- and an unclaimed
extension is not code to the sniffer at all, so those files were chunked
into several body-only records with no `language`, no `defs` and no
`symbols`. Agent-facing code search over a Kotlin/Swift/Elixir/Zig repo
degraded to substring matching.

Reproduced at HEAD before the fix (real run, not inferred): a folder of
Kotlin/Swift/Lua/Elixir fixtures indexed by `xerj autoindex` against a
live server produced 8 documents from 4 files, every one of them with
`language: null, symbols: null, defs: null`.

What changed
------------
21 languages, one grammar dep + one registry row + one capture query each,
exactly as the registry was designed for:

  Tier 1  Kotlin, Swift, Scala, Dart, Lua, Perl, R, Julia, Haskell, Elixir
  Tier 2  Erlang, OCaml (+ .mli), Zig, Objective-C, Groovy, PowerShell,
          F#, Nix
  Tier 3  Fortran (free-form), MATLAB, Solidity

Registry is 35 rows / 34 languages -- OCaml needs two rows because `.ml`
and `.mli` are separate grammars. `documented_language_count` pins that
number to the docs so the public claim cannot drift.

Three registry mechanics were added to support them:

* Text-predicate evaluation (`predicates_hold`). The core library exposes
  `#eq?`/`#any-of?` as *general* predicates and applies NONE of them. In
  Elixir `def` is itself a macro, so a definition is a `call` whose target
  spells a def-keyword -- without predicate evaluation every function call
  in the file would land in `defs`. `def()` rejects operators this does
  not implement at registry-build time, so an unsupported predicate fails
  `all_queries_compile` rather than silently matching everything.
* Extension-collision policy (issue's design decision #1), decided once
  and applied to all collisions: content probe where BOTH owners are
  registered, dominant-owner-documented where only one is. `.m` is the
  only real case -- Objective-C markers (`#import`/`@interface`/...) win,
  MATLAB is the probe-less fallback row. `.pl` -> Perl, `.r` -> R,
  `.sc` -> Scala, and `.h` -> C (unchanged) are dominant-owner rows with
  the reasoning in-line.
* `_`-prefixed captures are predicate-only and never emitted as symbols.

Query provenance
----------------
Where the grammar crate ships an author-written `queries/tags.scm`, the
definition patterns are ADAPTED from it and cited in-line (Swift, Scala,
Dart, Lua, R, Elixir, OCaml, F#, Nix, Fortran, MATLAB, Solidity);
reference-captures and doc-comment plumbing are dropped, and `val`/`var`/
property captures are dropped where they are the locals trap measured for
C in #170. Where no tags.scm ships (Kotlin, Perl, Julia, Haskell, Erlang,
Zig, Objective-C, Groovy, PowerShell) patterns are derived from the
grammar's own `src/node-types.json` and pinned by fixture tests.

Locals-trap anchoring is re-derived per grammar, not assumed:
Haskell anchors to `declarations` (a `where`-bound helper is a local),
F# keeps upstream's four top-level contexts (F# nests `let` constantly),
Zig anchors top-level `const` to `source_file`. Each has a negative
assertion in its test.

Deliberately NOT added, each with the reason recorded in Cargo.toml:
* Clojure -- its only release hard-links core ^0.25.6, mutually exclusive
  with the core 0.26 that tree-sitter-perl forces.
* source-SQL -- `tree-sitter-sql 0.0.2` is immature and `.sql` routing
  must not steal `sqldump` files (issue's design decision #3).
* Nim, Crystal -- their only releases are toy grammars (~17 node types,
  no proc/type/module nodes, verified in node-types.json); no alternative
  crate exists.
* fixed-form Fortran (`.f`) -- the grammar is free-form; a fixed-form file
  would parse to garbage, and an unclaimed extension still indexes as
  text, which is strictly better than a wrong AST.
* `tree-sitter-kotlin` 0.3.8 -- hard-links core >=0.21,<0.23; the `-ng`
  fork of the same fwcd grammar is used instead.

Core bump 0.25 -> 0.26, forced by `tree-sitter-perl 1.1.2` (the only new
grammar with a hard `links` dep on core); every other grammar binds
through `tree-sitter-language` and is version-agnostic. Same shape as the
c-sharp crate's 0.24 -> 0.25 bump.

Licences (issue acceptance criterion): all 21 grammar crates are MIT
except tree-sitter-elixir (Apache-2.0). Both compatible with XERJ's
Apache-2.0. Verified from each crate's own Cargo.toml in the registry
cache, not from a manifest.

Tests
-----
* `issue_295_extensions_route` -- the regression test. FAILS at
  origin/main 803c85b ("kt must be recognised as code", verified in a
  clean worktree), passes here. Pins all 33 newly claimed extensions to
  their language, and asserts the 5 deliberately-unclaimed ones stay
  unclaimed.
* `all_languages_load` -- the issue's ABI smoke test: instantiates every
  registered `Language` once, so an ABI-incompatible grammar fails in CI
  on all three OSes instead of at a user's first parse.
* `m_extension_content_probe` -- the `.m` decision, including that
  registry order (objc before matlab) is load-bearing.
* One real-world-shaped fixture per language asserting >=1 symbol of each
  captured kind, plus negative assertions for every locals trap.
  56 tests in `extract::code`, 0 failed.

Files
-----
- engine/crates/xerj-autoindex/src/extract/code.rs (registry, probes,
  predicate evaluation, 22 queries, fixtures)
- engine/crates/xerj-autoindex/Cargo.toml (deps + exclusion reasons)
- ROADMAP.md, landing/index.html (13 -> 34, pinned by test)

Fixes #295