fix(hir): mixin factories must register grandparent edge at runtime

[proggeramlug]

Summary

Fixes the chained-mixin TypeError: value is not a function that the #806 harness surfaced on PR #822. Root cause: class expressions inside a function body (the canonical mixin shape) had their extends_expr captured at HIR level but never evaluated — only top-level class declarations had a RegisterClassParentDynamic statement emitted for them. So in

function WithA<TBase extends Ctor>(B: TBase) {
  return class extends B { a() { return "a"; } };
}
class Chained extends WithA(WithB(WithC(CoreBase))) {}

Chained → Anon3 got wired (via the top-level class-decl arm), but Anon3 → Anon2 → Anon1 → CoreBase was never registered. chained.a() worked; chained.core() walked one level and threw.

Minimal repro

class Base { m() { return "base"; } }
function Mix<T extends new(...a:any[])=>{}>(B: T) {
  return class extends B { x() { return "x"; } };
}
class Sub extends Mix(Base) {}
new Sub().m();  // TypeError before; "base" after

The const M = Mix(Base); class Sub extends M {} form already worked because the const path takes a different lowering branch that synthesizes a named class.

Fix

One arm in crates/perry-hir/src/lower.rs (the ast::Expr::Class lowering). When the lowered class has extends_expr, return

Expr::Sequence([
  Expr::RegisterClassParentDynamic { class_name, parent_expr },
  Expr::ClassRef(class_name),
])

instead of a bare Expr::ClassRef. Sequence is the existing comma-operator primitive whose codegen evaluates each element in order and returns the last — so the side effect runs every time the factory function executes, and the value the call site sees is unchanged. No new HIR variant, no codegen changes, no boilerplate through walker/monomorph/analysis/stable_hash/js_transform.

Test plan

• 1-deep mixin (class X extends Mix(Base) {}) — new X().m() returns "base" (was TypeError).
• 3-deep chained mixin (extends WithA(WithB(WithC(Base)))) — all 4 methods (core/a/b/c) dispatch correctly.
• cargo test --release -p perry-hir -p perry-codegen — all green.
• 4-test class smoke (test_simple_class, test_get_prototype_of_instance, test_issue_711_function_prototype, test_gap_class_advanced) — all PASS byte-for-byte vs Node.

What the #806 harness still surfaces

Four unrelated gaps stay visible (no longer cascading from the TypeError):

• Bare-factory base-class field initializer is dropped (bare.kind: undefined).
• super(arg) in a mixin constructor doesn't propagate the arg.
• Static method dispatch on a factory-returned class returns garbage.
• Effect double-call factory (TaggedError<X>()("tag", schema)) doesn't bind _tag.

Each is now independently visible — they'd been masked by the cascading TypeError.

Refs #321, closes the chained-mixin sub-case of #806's harness.