Fix panic when lookahead hits EOF before finding close paren

When skipping a parenthesized expression at top level, the lookahead loop
might hit EndOfFile before finding the matching close paren. In this case,
we should not try to advance past the EOF token as that would cause an
assertion failure in peek().

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rtfeldman

src/parse/Parser.zig

@@ -1702,32 +1702,38 @@ fn parseStmtByType(self: *Parser, statementType: StatementType) Error!AST.Statem
             } else if (statementType == .top_level) {
                 // At top level, a parenthesized expression like (x + 1) or (x = 5).foo()
                 // is not valid. Skip past the parentheses and any suffix to produce a single error.
-                self.pos = lookahead_pos + 1; // Move past the closing paren
-                // Skip any suffix operators (e.g., .foo(), !(), etc.)
-                while (true) {
-                    switch (self.peek()) {
-                        .NoSpaceDotLowerIdent, .NoSpaceDotUpperIdent => {
-                            self.advance();
-                        },
-                        .NoSpaceOpenRound => {
-                            self.advance();
-                            // Skip to matching close paren
-                            var paren_depth: u32 = 1;
-                            while (paren_depth > 0 and self.peek() != .EndOfFile) {
-                                switch (self.peek()) {
-                                    .OpenRound, .NoSpaceOpenRound => paren_depth += 1,
-                                    .CloseRound => paren_depth -= 1,
-                                    else => {},
+                // Check if we found a matching close paren or hit EOF
+                const tok_at_lookahead = self.tok_buf.tokens.items(.tag)[lookahead_pos];
+                if (tok_at_lookahead == .CloseRound) {
+                    self.pos = lookahead_pos + 1; // Move past the closing paren
+                    // Skip any suffix operators (e.g., .foo(), !(), etc.)
+                    while (self.peek() != .EndOfFile) {
+                        switch (self.peek()) {
+                            .NoSpaceDotLowerIdent, .NoSpaceDotUpperIdent => {
+                                self.advance();
+                            },
+                            .NoSpaceOpenRound => {
+                                self.advance();
+                                // Skip to matching close paren
+                                var paren_depth: u32 = 1;
+                                while (paren_depth > 0 and self.peek() != .EndOfFile) {
+                                    switch (self.peek()) {
+                                        .OpenRound, .NoSpaceOpenRound => paren_depth += 1,
+                                        .CloseRound => paren_depth -= 1,
+                                        else => {},
+                                    }
+                                    self.advance();
                                 }
+                            },
+                            .OpBang => {
                                 self.advance();
-                            }
-                        },
-                        .OpBang => {
-                            self.advance();
-                        },
-                        else => break,
+                            },
+                            else => break,
+                        }
                     }
                 }
+                // If we didn't find matching close paren, just consume the open paren
+                // and fall through to produce an error at start position
                 return try self.pushMalformed(AST.Statement.Idx, .statement_unexpected_token, start);
             }
         },