Store a function's signature once, and expose it to primitives

[oflatt-claude]

Three additions to what a primitive body can see. None are specific to any one
extension: together they are what an out-of-tree primitive needs to walk the
term structure under an e-class and build a modified copy of it.

The motivating consumer is an unstable-subst substitution primitive in
egraphs-good/egglog-experimental#60, which lives there rather
than here because substitution is a language experiment, not core e-graph
machinery. This PR is only the introspection; it is worth reviewing on its own
terms.

Read::enodes_for_eclass(name, eclass, f)

Walks a constructor's rows by output e-class through the backend's lazy column
index, instead of scanning the table and filtering. Cherry-picked from #934,
along with the core-relations ExecutionState::for_each_matching_col and
egglog-bridge TableAction::for_each_output_value it rests on — credit to
that PR; this takes only the traversal hunks and none of the extraction work.

Read::constructor_schema(name), Read::function_schema(name), Read::table_subtype(name)

A table's declared signature, and whether it is a constructor or a function.
EGraph::functions_iter already exposes this from &EGraph, but a primitive
body only ever sees a state wrapper, and those carried no sort information at
all — so a primitive could read rows without being able to tell an e-class
column from a base value, or a constructor's eclass column from a function's
output.

The schema accessor is split by subtype and errors with WrongSubtype on a
mismatch, matching how the rest of Read and Write already work
(lookup/eclass_of, constructor_enodes/function_entries, set/add).
That split is not just cosmetic: a constructor's last column is an e-class and
a function's is an output. table_subtype is the error-free predicate for code
that accepts either.

Breaking: a signature is now stored once

The first cut of this branch added a FunctionSchemas registry to back those
accessors. That was a third copy of data egglog already kept twice —
TypeInfo::func_types holds a FuncType {name, subtype, input, output}, and
Function held the same content again as a ResolvedSchema plus
decl.subtype (and a third time, unresolved, in decl.schema). What was
missing was never the data, only a way to reach it from a state wrapper.

So TypeInfo::func_types became the single store and the shared cell, and the
new registry is gone:

• TypeInfo::get_func_type returns Option<Arc<FuncType>>, not
  Option<&FuncType>.
• Function points at the same Arc<FuncType>;
  Function::schema() -> &ResolvedSchema becomes
  Function::func_type() -> &FuncType.
• ResolvedSchema is removed; its get_by_pos moves to FuncType.
• declare_function reuses the signature typechecking already resolved instead
  of resolving the sorts a second time. It still resolves and records the
  functions desugaring generates (global bindings, proof tables), which never
  go through typechecking — so func_types now covers every declared table.

Two subtleties worth a reviewer's eye. TypeInfo::clone deep-copies the map: a
clone is an independent e-graph — a pushed copy, or the parallel typechecking
the proof checker keeps in original_typechecking — and declaring a function in
one must not make it resolve in the other. And pop restores the pushed
contents into the live cell the registered primitives already hold, rather than
swapping in a cell they have no handle to.

Primitive invocation cost is unchanged: the wrapper holds the unlocked handle
and the schema accessors lock only when called, so a primitive that never asks
pays nothing.

table_subtype also retires an existing workaround in egglog-experimental,
which determines a table's subtype by starting a constructor scan and reading
the error off the subtype check — removed in the companion PR.

Core::rebuild_container(type_id, value, remap)

Remaps a container value's contents and interns the result, over the existing
ContainerValues::rebuild_val_with. Out-of-tree code cannot reach this through
Core::register_container, which requires naming the container's Rust type —
impossible for an arbitrary container sort.

Notes

• No behaviour change to existing programs; this is additive.
• FunctionSchemas costs one HashMap entry per declared table.
• Adds one rule to the repo's tidy-diff-docs skill: prefer an import over an
  inline full path for a type.
• Verified: full workspace test suite passes (including the 799-program files
  harness), cargo clippy --tests --workspace clean, cargo fmt --check clean,
  and cargo doc adds no new warnings.

🤖 Generated with Claude Code

[codspeed-hq]

Merging this PR will not alter performance

✅ 37 untouched benchmarks
⏩ 227 skipped benchmarks¹

---

_{Comparing oflatt-claude:subst-egraph-introspection (1118c51) with main (716c320)}

Footnotes

1. 227 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩