fix(ssa): apply @reference heap-layout rule for Type::Unresolved too

`convert_type` already wraps `@reference` user types in
`Ptr(Struct(...))` when the typed AST hands us `Type::Named(id)`,
but the parallel `Type::Unresolved(name)` arm — which fires for
type references inside `impl` method bodies (`Vec3R { ... }`
inside `impl Add<Vec3R> for Vec3R`) — returned a bare
`Struct(...)`, missing the `is_reference` check. The constructor
lowering then took the value-type path (chained `InsertValue`
producing a struct SSA value rather than a malloc + per-field
store + pointer return) and downstream field-access GEPs took a
struct value as their `ptr` operand, panicking at
`into_pointer_value()` (llvm_backend.rs:1363).

The fix mirrors the `is_reference` check from the `Named` arm
into the `Unresolved` arm.

Bench impact: `bench_op_overload_ref` (1M iter × 2 calls = 2M
heap-Vec3R `+` ops) now runs cleanly through the LLVM tier — was
falling back to Cranelift silently because the BG-thread compile
panicked. ~30 ms exec, returning `Int(21000000)`.

CI gate: `bench_op_overload_ref` is now in the value-asserted
KERNELS list so any future regression that re-introduces this
shape gets caught loudly instead of falling back to Cranelift in
the background.

Author: darmie

crates/compiler/src/ssa.rs

@@ -7542,6 +7542,25 @@ impl SsaBuilder {
                         .map(|field| self.convert_type(&field.ty))
                         .collect();
 
+                    // Same `@reference` heap-layout check the `Type::Named`
+                    // arm above performs — Unresolved arrived here because
+                    // an earlier resolution stage produced `Unresolved(name)`
+                    // instead of `Named(id)`, which happens for type
+                    // references inside `impl` method bodies (`Vec3R { ... }`
+                    // inside `impl Add<Vec3R> for Vec3R`). Without this
+                    // mirror, the constructor lowering builds a value-type
+                    // struct via `insertvalue` chains, the field-access
+                    // path then issues a GEP whose `ptr` operand is the
+                    // struct value, and the LLVM backend panics at
+                    // `into_pointer_value()` (llvm_backend.rs:1363).
+                    if type_def.metadata.is_reference {
+                        return HirType::Ptr(Box::new(HirType::Struct(HirStructType {
+                            name: Some(type_def.name),
+                            fields: hir_fields,
+                            packed: false,
+                        })));
+                    }
+
                     HirType::Struct(HirStructType {
                         name: Some(type_def.name),
                         fields: hir_fields,

crates/zynml/examples/bench_op_overload_ref.zynml

@@ -0,0 +1,25 @@
+import prelude
+
+@reference
+struct Vec3R {
+    x: f64, y: f64, z: f64
+}
+
+impl Add<Vec3R> for Vec3R {
+    def add(self, other: Vec3R): Vec3R {
+        return Vec3R { x: self.x + other.x, y: self.y + other.y, z: self.z + other.z }
+    }
+}
+
+def main(): i64 {
+    let mut acc = Vec3R { x: 0.0, y: 0.0, z: 0.0 }
+    let a = Vec3R { x: 1.0, y: 2.0, z: 3.0 }
+    let b = Vec3R { x: 4.0, y: 5.0, z: 6.0 }
+    let mut i: i64 = 0
+    while i < 1000000 {
+        acc = acc + a
+        acc = acc + b
+        i = i + 1
+    }
+    return (acc.x + acc.y + acc.z) as i64
+}

crates/zynml/examples/bench_runner.rs

@@ -195,6 +195,7 @@ const KERNELS: &[(&str, &str)] = &[
     // a=(1,2,3), b=(4,5,6) → acc = (50000000, 70000000, 90000000)
     // → sum 210000000.
     ("bench_op_overload", "Int(210000000)"),
+    ("bench_op_overload_ref", "Int(21000000)"),
 ];
 
 /// Each target produces one [`TargetResult`] per kernel.