feat(elixir): index Elixir with Phoenix, Plug and Ecto flow coverage

[ferrine]

Branch: ferrine:feat/elixir-support → main
Size: 10 files, +1806/−1 · Tests: 26 in __tests__/extraction.test.ts
Grammar: tree-sitter-elixir from tree-sitter-wasms (already vendored, ABI
health-checked — no new dependency, no new .wasm).

Why

Elixir was unsupported. Added following .claude/skills/add-lang.

What changed

src/extraction/languages/elixir.ts, plus the four standard wiring edits.

Elixir's grammar is homoiconic — every construct is a call node, including
defmodule and def — so there are no declaration node types to map and
everything dispatches through the visitNode hook. Two grammar details worth
flagging for review, because both produced silent, total extraction failures
before they were found:

• arguments is a plain named child of a call, not a field (only target
  is), so childForFieldName('arguments') never finds it.
• a keyword node's text spans trailing whitespace ("for: "), so it must be
  trimmed before comparison.

Indexed: modules including nested ones with @moduledoc; public/private
functions with @doc and @spec; macros, guards, operator definitions,
defdelegate targets; defstruct/defexception fields; @type/@opaque;
module attributes as constants; protocols and their defimpl; @behaviour
links; alias/import/require/use with alias/as:/{A, B} expansion so
remote calls resolve to the real module; &fun/1 captures; %Struct{}
instantiation.

Multi-clause functions are merged into one symbol per arity rather than one
node per clause — the GenServer idiom otherwise indexes a 6-clause
handle_call as six identical nodes with caller edges landing on an arbitrary
one. Adjacency is a safe merge key because Elixir warns on any non-adjacent
redefinition. Same-name different-arity stays separate.

Kernel.SpecialForms and the Kernel macros that are language syntax are
suppressed as call targets — without that list every if/case/quote mints a
calls ref, and a project that legitimately defines def send/2 collects
hundreds of wrong caller edges.

Framework coverage: Phoenix routes as symbols linked to the controller
action they dispatch to (nested scope paths and aliases, resources
expansion, forward, live); Plug pipeline entries linked to the function
or plug that runs; Ecto schema fields and association edges.

Generated-protobuf modules

A protobuf generator writes a module's shape as bare macro calls in the module
body — field :observed_at, 3, type: :string, oneof, rpc — with no
enclosing block. Ecto's schema do … end gives its fields a block to be
recognised by; these have nothing but the use Protobuf / use GRPC.Service
marker at the top of the module, so they were doing damage twice over: the
declarations went missing entirely, and the macro calls resolved by name, so a
project that defines its own field/2 collected every generated field in the
repo as a caller of that one unrelated helper.

Reading the use marker fixes both. Fields carry their tag, an enum's values
become enum_member, and an rpc links to the request and response messages it
names — including through a stream(...) wrapper. Gated on the marker, so a
hand-written field(...) call in an ordinary module still resolves as a call,
and the marker stops applying at the end of its own module.

Notes for review

assets/languages/elixir.svg uses the published simple-icons path plus a
wordmark recomposed from published glyph metrics — not hand-drawn.