Fix test regressions in op/repeat.t and op/tiehash.t

This commit fixes test regressions introduced by commit a039ec0.

Test Results:
- op/repeat.t: 47/50 passing (was 0/50, now restored to baseline)
- op/tiehash.t: 27/27 passing (was 0/27, now fully restored)

Fixes Applied:

1. OperatorParser.java - Fix scalar operator parsing
   - Removed ensureOneOperand() check for scalar operator only
   - scalar can accept comma expressions like scalar((nil) x 3, 1)
   - values/keys/each still need single operand check
   - Fixes op/repeat.t regression

2. RuntimeScalar.java - Add UNDEF autovivification to NonStrict methods
   - arrayDerefNonStrict() now handles UNDEF case (creates autovivified array)
   - hashDerefNonStrict() now handles UNDEF case (creates autovivified hash)
   - Matches behavior of arrayDeref() and hashDeref() for consistency
   - Required for autovivification when strict refs is disabled

3. RuntimeBaseProxy.java - Fix proxy state synchronization
   - arrayDeref() and hashDeref() now update proxy type/value after vivification
   - Added arrayDerefNonStrict() and hashDerefNonStrict() overrides
   - All four methods now properly sync proxy state with lvalue
   - Fixes tied hash autovivification in op/tiehash.t

Root Cause:
Commit a039ec0 added symbolic reference support but had bugs:
- Overly strict parser checks on scalar operator
- Missing autovivification in NonStrict methods
- Incomplete proxy state updates after vivification

Author: fglock

src/main/java/org/perlonjava/parser/OperatorParser.java

@@ -476,14 +476,18 @@ static OperatorNode parseKeys(Parser parser, LexerToken token, int currentIndex)
         // Handle operators with a single operand
         // For scalar, values, keys, each: parse with precedence that includes postfix operators ([], {}, ->)
         // Named unary operators have precedence between 20 and 21 in Perl
-        // This allows expressions like: values $hashref->%* or keys $hashref->%*
+        // This allows expressions like: values $hashref->%* or keys $hashref->%* or scalar((nil) x 3, 1)
         if (operator.equals("scalar") || operator.equals("values") || operator.equals("keys") || operator.equals("each")) {
             operand = parser.parseExpression(parser.getPrecedence("=~")); // precedence 20
-            // For values/keys/each, check if operand is null (no argument provided)
+            // Check if operand is null (no argument provided)
             if (operand == null) {
                 throw new PerlCompilerException(currentIndex, "Not enough arguments for " + operator, parser.ctx.errorUtil);
             }
-            operand = ensureOneOperand(parser, token, operand);
+            // scalar can accept comma expressions like scalar((nil) x 3, 1)
+            // but values/keys/each need single operand check
+            if (!operator.equals("scalar")) {
+                operand = ensureOneOperand(parser, token, operand);
+            }
         } else {
             operand = ParsePrimary.parsePrimary(parser);
             // Check if operand is null (no argument provided)

src/main/java/org/perlonjava/runtime/RuntimeBaseProxy.java

@@ -76,13 +76,41 @@ public RuntimeScalar set(boolean value) {
     @Override
     public RuntimeHash hashDeref() {
         vivify();  // Ensure the scalar exists in parent hash
-        return lvalue.hashDeref();  // Delegate to the actual scalar
+        RuntimeHash result = lvalue.hashDeref();  // Delegate to the actual scalar
+        // Update proxy's type and value to match lvalue after vivification
+        this.type = lvalue.type;
+        this.value = lvalue.value;
+        return result;
     }
 
     @Override
     public RuntimeArray arrayDeref() {
         vivify();  // Ensure the scalar exists in parent hash
-        return lvalue.arrayDeref();  // Delegate to the actual scalar
+        RuntimeArray result = lvalue.arrayDeref();  // Delegate to the actual scalar
+        // Update proxy's type and value to match lvalue after vivification
+        this.type = lvalue.type;
+        this.value = lvalue.value;
+        return result;
+    }
+
+    @Override
+    public RuntimeArray arrayDerefNonStrict(String packageName) {
+        vivify();  // Ensure the scalar exists in parent hash/array
+        RuntimeArray result = lvalue.arrayDerefNonStrict(packageName);  // Delegate to the actual scalar
+        // Update proxy's type and value to match lvalue after vivification
+        this.type = lvalue.type;
+        this.value = lvalue.value;
+        return result;
+    }
+
+    @Override
+    public RuntimeHash hashDerefNonStrict(String packageName) {
+        vivify();  // Ensure the scalar exists in parent hash/array
+        RuntimeHash result = lvalue.hashDerefNonStrict(packageName);  // Delegate to the actual scalar
+        // Update proxy's type and value to match lvalue after vivification
+        this.type = lvalue.type;
+        this.value = lvalue.value;
+        return result;
     }
 
     /**

src/main/java/org/perlonjava/runtime/RuntimeScalar.java

@@ -918,6 +918,13 @@ public RuntimeHash hashDerefNonStrict(String packageName) {
         }
 
         return switch (type) {
+            case UNDEF -> {
+                // Don't autovivify read-only scalars (like constants)
+                if (this instanceof RuntimeScalarReadOnly) {
+                    yield new RuntimeHash();
+                }
+                yield AutovivificationHash.createAutovivifiedHash(this);
+            }
             case HASHREFERENCE -> (RuntimeHash) value;
             case TIED_SCALAR -> tiedFetch().hashDerefNonStrict(packageName);
             default -> {
@@ -946,6 +953,14 @@ public RuntimeArray arrayDerefNonStrict(String packageName) {
         }
 
         return switch (type) {
+            case UNDEF -> {
+                // Don't autovivify read-only scalars (like constants)
+                // This matches Perl's behavior where 1->[0] returns undef without error
+                if (this instanceof RuntimeScalarReadOnly) {
+                    yield new RuntimeArray();
+                }
+                yield AutovivificationArray.createAutovivifiedArray(this);
+            }
             case ARRAYREFERENCE -> (RuntimeArray) value;
             case TIED_SCALAR -> tiedFetch().arrayDerefNonStrict(packageName);
             default -> {