fix(lower): diagnose .* on a non-pointer instead of codegen panic

`lowerDerefExpr` left the deref's result type `.unresolved` when the
operand wasn't a pointer (e.g. a stale `value.*` after a parameter
changed from `*T` to `T`), and emitted the `.deref` anyway. That
unresolved type slipped through to emit_llvm's "unresolved type reached
LLVM emission" panic with no source location.

Now it emits a clean diagnostic at the deref site
("cannot dereference with `.*`: 'T' is not a pointer") and recovers.
Regression: examples/254-deref-non-pointer-reject.sx.

examples/254-deref-non-pointer-reject.sx

@@ -0,0 +1,14 @@
+// `.*` on a non-pointer must be a clean compile diagnostic, NOT a codegen
+// panic. Regression: a stale `value.*` (e.g. after a parameter changed from
+// `*T` to `T` by value) used to lower a `.deref` with an `.unresolved` result
+// type, which slipped through to emit_llvm's "unresolved type reached LLVM
+// emission" panic with no source location. `lowerDerefExpr` now diagnoses it.
+// Expected: a clean error pointing at the deref; exit 1.
+
+Point :: struct { x: s32; y: s32; }
+
+main :: () -> s32 {
+    p : Point = .{ x = 3, y = 4 };
+    q := p.*;          // ERROR: `p` is a Point value, not a pointer
+    return q.x;
+}

src/ir/lower.zig

@@ -5483,16 +5483,22 @@ pub const Lowering = struct {
 
     fn lowerDerefExpr(self: *Lowering, de: *const ast.DerefExpr) Ref {
         const ptr = self.lowerExpr(de.operand);
-        // Resolve pointee type from the pointer type
+        // Resolve pointee type from the pointer type.
         const ptr_ty = self.inferExprType(de.operand);
-        var pointee_ty: TypeId = .unresolved;
         if (!ptr_ty.isBuiltin()) {
             const info = self.module.types.get(ptr_ty);
             if (info == .pointer) {
-                pointee_ty = info.pointer.pointee;
+                return self.builder.emit(.{ .deref = .{ .operand = ptr } }, info.pointer.pointee);
             }
         }
-        return self.builder.emit(.{ .deref = .{ .operand = ptr } }, pointee_ty);
+        // Operand isn't a pointer — `.*` is invalid. Diagnose here instead of
+        // emitting a `.deref` with an `.unresolved` result type, which would
+        // otherwise slip through to emit_llvm's "unresolved type reached LLVM
+        // emission" panic with no source location.
+        if (self.diagnostics) |d| {
+            d.addFmt(.err, de.operand.span, "cannot dereference with `.*`: '{s}' is not a pointer", .{self.formatTypeName(ptr_ty)});
+        }
+        return ptr;
     }
 
     fn lowerForceUnwrap(self: *Lowering, fu: *const ast.ForceUnwrap) Ref {

tests/expected/254-deref-non-pointer-reject.exit

@@ -0,0 +1 @@
+1

tests/expected/254-deref-non-pointer-reject.txt

@@ -0,0 +1,5 @@
+error: cannot dereference with `.*`: 'Point' is not a pointer
+  --> /Users/agra/projects/sx/examples/254-deref-non-pointer-reject.sx:12:10
+   |
+12 |     q := p.*;          // ERROR: `p` is a Point value, not a pointer
+   |          ^