Remove unnecessary context allocation

[vinistock]

Currently, we are allocating a new LinearizationContext each time for ancestors_of. This is completely unnecessary because the linearization recursion already cleans up the context object.

We can simply reuse the same object stored in the Resolver, avoid the allocation entirely and remove ancestors_of while we're at it. This provides a 12% speed up for resolution, bringing us to ~11s.

[soutaro]

I find the lifecycle of LinearizationContext harder to follow when it is mutated implicitly through Resolver. Could we keep the reuse as an implementation detail of ancestors_of, while making the active traversal state explicit?

For example, ancestors_of could take the reusable context out, initialize it, pass it explicitly through the traversal, validate that it has been cleaned up, and then put it back:

let mut context = self
    .reusable_linearization_context
    .take()
    .expect("ancestor linearization must not be re-entered");

context.begin();
let result = self.linearize_ancestors(declaration_id, &mut context);
debug_assert!(context.is_idle());

self.reusable_linearization_context = Some(context);
result

This retains the allocation benefit, while making the context’s lifetime and ownership at a traversal call site easier to reason about. Using Option would also make accidental re-entry fail explicitly, instead of silently taking a new default context.

---

By the way, a 12% speedup from allocation reduction alone seems a little surprising. What is actually driving the improvement?