Fix interpreter: glob assignment lvalue, DEREF error propagation, each/chop

- CompileAssignment: handle '*' as glob lvalue (e.g. 'foo'->** = 'bar'->**)
  Fixes: op/postfixderef.t tests 27-29 (glob access syntax)

- BytecodeInterpreter DEREF: always call scalarDeref() so non-reference types
  (IO, FORMAT, etc.) correctly throw 'Not a SCALAR reference'
  Fixes: op/postfixderef.t tests 59, 63

- CompileOperator each: force LIST context on operand so %h remains a
  RuntimeHash instead of being converted to ARRAY_SIZE via scalar context
  Fixes: op/lex_assign.t test 86 (each %h inside scalar assignment)

- OpcodeHandlerExtended.executeChop: use polymorphic .chop() instead of
  hard-casting to RuntimeScalar

- MiscOpcodeHandler: handle EACH before RuntimeList cast since EACH now
  receives the container (RuntimeHash/RuntimeArray) directly

Author: fglock

src/main/java/org/perlonjava/backend/bytecode/BytecodeInterpreter.java

@@ -1405,15 +1405,10 @@ public static RuntimeList execute(InterpretedCode code, RuntimeArray args, int c
                         int rs = bytecode[pc++];
                         RuntimeBase value = registers[rs];
 
-                        // Only dereference if it's a RuntimeScalar with REFERENCE type
-                        if (value instanceof RuntimeScalar) {
-                            RuntimeScalar scalar = (RuntimeScalar) value;
-                            if (scalar.type == RuntimeScalarType.REFERENCE) {
-                                registers[rd] = scalar.scalarDeref();
-                            } else {
-                                // Non-reference scalar, just copy
-                                registers[rd] = value;
-                            }
+                        if (value instanceof RuntimeScalar scalar) {
+                            // Always go through scalarDeref() so non-reference types throw
+                            // "Not a SCALAR reference" (matches JVM path behaviour)
+                            registers[rd] = scalar.scalarDeref();
                         } else {
                             // RuntimeList or other types, pass through
                             registers[rd] = value;

src/main/java/org/perlonjava/backend/bytecode/CompileAssignment.java

@@ -991,6 +991,22 @@ public static void compileAssignmentOperator(BytecodeCompiler bytecodeCompiler,
                     } else {
                         bytecodeCompiler.throwCompilerException("Assignment to unsupported array dereference");
                     }
+                } else if (leftOp.operator.equals("*")) {
+                    // Glob assignment: *foo = *bar  or  'foo'->** = ...
+                    // Compile LHS glob, compile RHS, emit STORE_GLOB
+                    int savedCtx = bytecodeCompiler.currentCallContext;
+                    bytecodeCompiler.currentCallContext = RuntimeContextType.LIST;
+                    node.left.accept(bytecodeCompiler);
+                    bytecodeCompiler.currentCallContext = savedCtx;
+                    int globReg = bytecodeCompiler.lastResultReg;
+
+                    node.right.accept(bytecodeCompiler);
+                    int valueReg2 = bytecodeCompiler.lastResultReg;
+
+                    bytecodeCompiler.emit(Opcodes.STORE_GLOB);
+                    bytecodeCompiler.emitReg(globReg);
+                    bytecodeCompiler.emitReg(valueReg2);
+                    bytecodeCompiler.lastResultReg = globReg;
                 } else {
                     // chop/chomp cannot be used as lvalues (matches JVM compiler message)
                     if (leftOp.operator.equals("chop") || leftOp.operator.equals("chomp")) {