Per-path profiling, child-call kind, and call columns

[revarbat]

Three changes to the profiler's data model. All were held back by the
Actions outage; they were developed on top of #76 and are rebased onto
main now that it has merged.

Per-path profiling (0.19.0)

ProfileResult gains paths: a calling-context tree, one node per call
site reached by one specific path from <toplevel>. Where callSites
aggregates a site over every path that reached it, this keeps them
apart — so cuboid called from bracket and cuboid called from rail
have their own times, and a consumer can show what a particular path
actually cost.

Flat vector with parent/child indices, not pointers: it survives the
vector reallocating and crosses the Python binding as plain data.

Recursion folds rather than unrolling — re-entering a site already on the
path reuses that node, so 400-deep recursion is one node with
callCount 400.

Cumulative time is derived bottom-up in finalizeProfilePaths() rather
than measured per entry. Measuring per entry counted only the outermost
entry at a fold while children accumulated across all of them, which
broke containment: 6 of 9217 nodes had children summing past their
parent.

child kind (0.20.0)

module foo(x) { foo(x+1); } and foo() foo(); both produce a foo→foo
edge, but only the first is recursion — the second hands foo to foo as a
child. Reporting both as "module" invites reading one as the other.

EvalContext gains viaChildren, set where prepareChildrenForward
builds the forwarding context so both its return paths carry it. It
propagates through withScope/childCtx (a forwarded translate() foo()
is still child-passing) but callCtx resets it, so entering a body ends
the forwarding. buildModuleChildCtx is the single funnel every module
call goes through, native and VM alike; enterUserCall consumes the flag,
so a plain call inside a forwarded body stays an ordinary module call.

Call column (0.21.0)

m(); m(); is two call sites, but keyed by (kind, name, origin, line)
they aggregated into one entry: one row carrying both calls' time with a
call count of 2. f(g(x)) and foo() foo(); had the same problem.

Column now sits in ProfileSiteKey and in the tree's fold and sibling
match. CallSiteProfile and ProfilePathNode both carry callColumn;
the bindings expose call_column. The CLI report shows
file:line:column, gains a call_column CSV field, and its sort
tie-break follows the key — otherwise two sites on one line order
arbitrarily between runs.

Tests

1407 pass. New coverage for the child/recursion distinction, that the
flag does not leak into a forwarded body, and that two calls on one line
stay two call sites and two tree nodes.

The containment test was rewritten after it passed against the broken
implementation — its original fixture had no recursion through a module
call, so it never exercised the case it existed for. It now asserts
multiEntry > 0 to guard the fixture itself.

🤖 Generated with Claude Code