refactor: properly separate type resolution between parser and compiler

**Architecture**:
- Parser builds TypedAST with Type::Unresolved for unknown types
- Parser tracks declared types (from @opaque, struct, enum) for immediate resolution
- Compiler resolves all Type::Unresolved via TypeRegistry before lowering
- SSA builder now sees fully resolved types for proper trait dispatch

**Changes**:
- Added Type::Unresolved variant for types to be resolved by compiler
- Parser tracks declared_types HashMap for types defined in current file
- Added resolve_unresolved_types pass in runtime before lowering
- Removed duplicate type resolution logic from embed runtime
- Fixed constraint solver to handle Type::Unresolved
- Lowering still has Type::Unresolved handling as fallback

**Result**:
Operator overloading with imported types now works correctly - types are
resolved before SSA, enabling proper trait dispatch for binary operations.

Author: darmie

crates/compiler/src/lowering.rs

@@ -966,6 +966,19 @@ impl LoweringContext {
                 HirType::Opaque(*name)
             }
 
+            Type::Unresolved(name) => {
+                // Look up the type in TypeRegistry aliases
+                eprintln!("[DEBUG convert_type] Resolving unresolved type '{}'", name.resolve_global().unwrap_or_default());
+                if let Some(resolved_type) = self.type_registry.resolve_alias(*name) {
+                    eprintln!("[DEBUG convert_type] Found alias for '{}': {:?}", name.resolve_global().unwrap_or_default(), resolved_type);
+                    // Recursively convert the resolved type
+                    self.convert_type(resolved_type)
+                } else {
+                    eprintln!("[WARN] Could not resolve type '{}', defaulting to I64", name.resolve_global().unwrap_or_default());
+                    HirType::I64 // Fallback
+                }
+            }
+
             Type::Named { id, .. } => {
                 // Look up type definition in registry
                 if let Some(type_def) = self.type_registry.get_type_by_id(*id) {

crates/typed_ast/src/constraint_solver.rs

@@ -248,7 +248,8 @@ impl Substitution {
             | Type::Any
             | Type::Error
             | Type::HigherKinded { .. }
-            | Type::Extern { .. } => ty.clone(),
+            | Type::Extern { .. }
+            | Type::Unresolved(_) => ty.clone(),
             Type::Nullable(inner_ty) => {
                 // For nullable types, substitute the inner type and maintain nullability
                 let substituted_inner = self.apply(inner_ty);
@@ -2644,6 +2645,10 @@ impl ConstraintSolver {
                 // Format extern/opaque type by name
                 name.resolve_global().unwrap_or_else(|| format!("extern_{}", name.symbol().to_usize()))
             }
+            Type::Unresolved(name) => {
+                // Format unresolved type by name
+                name.resolve_global().unwrap_or_else(|| format!("unresolved_{}", name.symbol().to_usize()))
+            }
         }
     }
 
@@ -3400,7 +3405,8 @@ impl ConstraintSolver {
             | Type::Error
             | Type::SelfType
             | Type::HigherKinded { .. }
-            | Type::Extern { .. } => ty.clone(),
+            | Type::Extern { .. }
+            | Type::Unresolved(_) => ty.clone(),
             Type::Nullable(inner_ty) => {
                 // For nullable types, substitute the inner type and maintain nullability
                 let substituted_inner = self.resolve_associated_types(inner_ty, receiver_type);
@@ -3458,7 +3464,7 @@ impl ConstraintSolver {
                 associated_types,
                 super_traits,
             } => todo!(),
-            Type::Extern { .. } => ty.clone(),
+            Type::Extern { .. } | Type::Unresolved(_) => ty.clone(),
         }
     }
 
@@ -3571,7 +3577,8 @@ impl ConstraintSolver {
             | Type::Error
             | Type::Associated { .. }
             | Type::HigherKinded { .. }
-            | Type::Extern { .. } => ty.clone(),
+            | Type::Extern { .. }
+            | Type::Unresolved(_) => ty.clone(),
             Type::Nullable(inner_ty) => {
                 // For nullable types, substitute the inner type and maintain nullability
                 let substituted_inner = self.substitute_self_type(inner_ty, receiver_type);

crates/typed_ast/src/type_registry.rs

@@ -436,6 +436,11 @@ pub enum Type {
         name: InternedString,
         layout: Option<ExternLayout>,
     },
+
+    /// Unresolved type name (placeholder from parser, to be resolved by compiler)
+    /// The compiler's type resolution pass will look this up in TypeRegistry aliases
+    /// and replace it with the actual type (e.g., Type::Extern)
+    Unresolved(InternedString),
 }
 
 /// Layout information for extern types (optional)

crates/zyn_peg/src/runtime.rs

@@ -1113,6 +1113,9 @@ pub struct TypedAstBuilder {
     variable_types: HashMap<String, Type>,
     /// Enum type name to variant names (in order, for discriminant calculation)
     enum_types: HashMap<String, Vec<String>>,
+    /// Type declarations defined in the current file (name -> Type)
+    /// Tracks types from @opaque, struct, enum declarations so type references can be resolved
+    declared_types: HashMap<String, Type>,
     /// Program declaration handles (in order)
     program_decls: Vec<NodeHandle>,
     /// Current span being processed (start, end)
@@ -1145,6 +1148,7 @@ impl TypedAstBuilder {
             types: HashMap::new(),
             variable_types: HashMap::new(),
             enum_types: HashMap::new(),
+            declared_types: HashMap::new(),
             program_decls: Vec::new(),
             current_span: (0, 0),
         }
@@ -1607,6 +1611,14 @@ impl AstHostFunctions for TypedAstBuilder {
         let name_interned = self.inner.intern(name);
         let runtime_prefix = self.inner.intern(external_name);
 
+        // Register this extern type so type references can be resolved
+        let extern_type = Type::Extern {
+            name: runtime_prefix,
+            layout: None,
+        };
+        self.declared_types.insert(name.to_string(), extern_type);
+        eprintln!("[DEBUG create_opaque_type] Registered extern type '{}' -> Extern({})", name, external_name);
+
         let extern_struct = TypedExternStruct {
             name: name_interned,
             runtime_prefix,
@@ -2090,15 +2102,10 @@ impl AstHostFunctions for TypedAstBuilder {
             "bool" => Type::Primitive(PrimitiveType::Bool),
             "void" | "unit" => Type::Primitive(PrimitiveType::Unit),
             _ => {
-                // Unknown type - use Named with placeholder for compiler resolution
-                eprintln!("[DEBUG create_primitive_type] Unknown type '{}', creating Named with placeholder TypeId(0)", name);
-                Type::Named {
-                    id: zyntax_typed_ast::TypeId::new(0),
-                    type_args: vec![],
-                    const_args: vec![],
-                    variance: vec![],
-                    nullability: zyntax_typed_ast::type_registry::NullabilityKind::NonNull,
-                }
+                // Unknown type - create unresolved for compiler resolution
+                eprintln!("[DEBUG create_primitive_type] Unknown type '{}', creating Unresolved", name);
+                let name_interned = self.inner.intern(name);
+                Type::Unresolved(name_interned)
             }
         };
         self.types.insert(handle, ty);
@@ -2124,16 +2131,16 @@ impl AstHostFunctions for TypedAstBuilder {
     fn create_named_type(&mut self, name: &str) -> NodeHandle {
         let handle = self.alloc_handle();
 
-        // Create a named type with placeholder ID (0)
-        // The compiler's type resolution phase will resolve this to the actual TypeId
-        // using the TypeRegistry
-        eprintln!("[DEBUG create_named_type] Creating named type '{}' with placeholder TypeId(0)", name);
-        let ty = Type::Named {
-            id: zyntax_typed_ast::TypeId::new(0),
-            type_args: vec![],
-            const_args: vec![],
-            variance: vec![],
-            nullability: zyntax_typed_ast::type_registry::NullabilityKind::NonNull,
+        // Check if this type was declared in the current file (e.g., via @opaque, struct, enum)
+        let ty = if let Some(declared_ty) = self.declared_types.get(name) {
+            eprintln!("[DEBUG create_named_type] Found declared type '{}': {:?}", name, declared_ty);
+            declared_ty.clone()
+        } else {
+            // Type not found in current file - create unresolved for compiler resolution
+            // This handles types from imports or forward references
+            eprintln!("[DEBUG create_named_type] Creating unresolved type '{}'", name);
+            let name_interned = self.inner.intern(name);
+            Type::Unresolved(name_interned)
         };
 
         self.types.insert(handle, ty);