Fix closure-unaware code paths in compiler

Object literal shorthand ({ x }) and for-in loop variable bindings
used find_local + Move, which would copy cell GcRefs instead of values
for captured variables. Updated both paths to use find_local_info with
proper CellLoad/CellStore/upvalue handling. Removed now-unused
find_local method.

Co-Authored-By: Claude Opus 4.6 (1M context) <[e-mail]>

crates/js/src/compiler.rs

···
         self.locals.iter().rev().find(|l| l.name == name)
     }
 
-    /// Look up a local variable by name (register only).
-    fn find_local(&self, name: &str) -> Option<Reg> {
-        self.find_local_info(name).map(|l| l.reg)
-    }
-
     /// Look up an upvalue by name, returning its index.
     fn find_upvalue(&self, name: &str) -> Option<u8> {
         self.upvalues
···
 
             // Bind the loop variable.
             match left {
-                ForInOfLeft::VarDecl { kind: _, pattern } => {
+                ForInOfLeft::VarDecl { kind, pattern } => {
                     if let PatternKind::Identifier(name) = &pattern.kind {
-                        let var_r = fc.define_local(name);
-                        fc.builder.emit_reg_reg(Op::Move, var_r, key_r);
+                        let is_captured = fc.captured_names.contains(name.as_str());
+                        let is_const = *kind == VarKind::Const;
+                        let var_r = fc.define_local_ext(name, is_captured, is_const);
+                        if is_captured {
+                            fc.builder.emit_reg(Op::NewCell, var_r);
+                            fc.builder.emit_reg_reg(Op::CellStore, var_r, key_r);
+                        } else {
+                            fc.builder.emit_reg_reg(Op::Move, var_r, key_r);
+                        }
                     }
                 }
                 ForInOfLeft::Pattern(pattern) => {
                     if let PatternKind::Identifier(name) = &pattern.kind {
-                        if let Some(local) = fc.find_local(name) {
-                            fc.builder.emit_reg_reg(Op::Move, local, key_r);
+                        if let Some(local) = fc.find_local_info(name) {
+                            let reg = local.reg;
+                            let captured = local.is_captured;
+                            if captured {
+                                fc.builder.emit_reg_reg(Op::CellStore, reg, key_r);
+                            } else {
+                                fc.builder.emit_reg_reg(Op::Move, reg, key_r);
+                            }
+                        } else if let Some(uv_idx) = fc.find_upvalue(name) {
+                            fc.builder.emit_store_upvalue(uv_idx, key_r);
                         } else {
                             let ni = fc.builder.add_name(name);
                             fc.builder.emit_store_global(ni, key_r);
···
                 } else {
                     // Shorthand: `{ x }` means `{ x: x }`.
                     if let PropertyKey::Identifier(name) = &prop.key {
-                        if let Some(local) = fc.find_local(name) {
-                            fc.builder.emit_reg_reg(Op::Move, val_reg, local);
+                        if let Some(local) = fc.find_local_info(name) {
+                            let reg = local.reg;
+                            let captured = local.is_captured;
+                            if captured {
+                                fc.builder.emit_reg_reg(Op::CellLoad, val_reg, reg);
+                            } else {
+                                fc.builder.emit_reg_reg(Op::Move, val_reg, reg);
+                            }
+                        } else if let Some(uv_idx) = fc.find_upvalue(name) {
+                            fc.builder.emit_load_upvalue(val_reg, uv_idx);
                         } else {
                             let ni = fc.builder.add_name(name);
                             fc.builder.emit_load_global(val_reg, ni);