Fix infinite loop with my sub closures inside subroutines

The issue was that 'my sub' assignments were being executed at
compile-time (in a BEGIN block) instead of at runtime. This caused
lexical subroutines to capture closure variables from the first
call rather than fresh values on each invocation of the enclosing
subroutine.

The fix differentiates:
- state sub: Execute once at compile time (BEGIN block) - unchanged
- my sub: Execute at runtime, creating fresh closure each scope entry

Additionally, this fix properly handles 'my sub' with signatures by
not consuming (...) as a prototype when signatures feature is enabled,
letting parseSubroutineDefinition handle it as a proper signature.

Fixes the infinite loop where a 'my sub inner' inside 'sub process'
would incorrectly retain the $callback from the first call even
when process was called again with undef.

Author: fglock

.gitignore

@@ -63,3 +63,5 @@ logs/
 test_*.log
 test_*.json
 
+t.pl
+test_yaml_0yml

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

@@ -276,13 +276,19 @@ public static Node parseStatement(Parser parser, String label) {
                                 }
 
                                 // Then check for prototype if not already set by attribute
-                                if (prototype == null && peek(parser).text.equals("(")) {
+                                // IMPORTANT: Only parse as prototype if signatures feature is NOT enabled
+                                // When signatures are enabled, let parseSubroutineDefinition handle (...) as a signature
+                                if (prototype == null && peek(parser).text.equals("(") 
+                                        && !parser.ctx.symbolTable.isFeatureCategoryEnabled("signatures")) {
                                     // Parse the prototype
                                     prototype = ((StringNode) StringParser.parseRawString(parser, "q")).value;
                                 }
 
                                 // Now check if there's a body
-                                hasBody = peek(parser).text.equals("{");
+                                // When signatures are enabled, (...) followed by { also indicates a body
+                                String peekText = peek(parser).text;
+                                hasBody = peekText.equals("{") || 
+                                         (peekText.equals("(") && parser.ctx.symbolTable.isFeatureCategoryEnabled("signatures"));
 
                                 if (hasBody) {
                                     // Full definition: my sub name {...} or my sub name (...) {...}
@@ -315,13 +321,21 @@ public static Node parseStatement(Parser parser, String label) {
                                     }
                                     BinaryOperatorNode assignment = new BinaryOperatorNode("=", varRef, anonSub, parser.tokenIndex);
 
-                                    // Execute assignment immediately during parsing (like a BEGIN block)
-                                    // This is crucial for cases like: state sub foo{...}; use overload => \&foo;
-                                    BlockNode beginBlock = new BlockNode(new ArrayList<>(List.of(assignment)), parser.tokenIndex);
-                                    SpecialBlockParser.runSpecialBlock(parser, "BEGIN", beginBlock);
-                                    
-                                    // Return empty list since the assignment already executed
-                                    yield new ListNode(parser.tokenIndex);
+                                    if (declaration.equals("state")) {
+                                        // For state sub: Execute assignment immediately during parsing (like a BEGIN block)
+                                        // This is crucial for cases like: state sub foo{...}; use overload => \&foo;
+                                        // The closure is created once and reused across all calls
+                                        BlockNode beginBlock = new BlockNode(new ArrayList<>(List.of(assignment)), parser.tokenIndex);
+                                        SpecialBlockParser.runSpecialBlock(parser, "BEGIN", beginBlock);
+                                        
+                                        // Return empty list since the assignment already executed
+                                        yield new ListNode(parser.tokenIndex);
+                                    } else {
+                                        // For my sub: Return the assignment to be executed at runtime
+                                        // This creates a fresh closure each time the enclosing scope is entered,
+                                        // correctly capturing the current values of closure variables
+                                        yield assignment;
+                                    }
                                 } else {
                                     // Forward declaration: my sub name; or my sub name ($);
                                     // For forward declarations, add &subName immediately since there's no body to be invisible in