perf(parser): cache cur_kind() to eliminate redundant calls (#14411)

## Summary
Optimization to reduce redundant token kind extraction in hot paths by caching `cur_kind()` results before compound checks.

## Problem
- Compound checks like `self.at(X) || self.at(Y)` call `cur_kind()` twice
- Pattern `self.at(close) || self.has_fatal_error()` calls `cur_kind()` twice since `has_fatal_error()` internally calls it
- Token kind extraction involves bit-packing operations: `((self.0 >> 64) & 0xFF) as u8`

## Solution
Cache `cur_kind()` in a local variable before compound checks to eliminate redundant calls.

## Changes
- **`cursor.rs:parse_delimited_list()`**: Hot loop parsing arrays, objects, parameters - reduced from 2-3 calls per iteration to 1
- **`arrow.rs:68`**: Cached kind for `LParen`/`LAngle` check
- **`module.rs:101`**: Cached kind for `LCurly`/`Star` check
- **`types.rs`**: Fixed 3 locations (lines 91, 558, 1188) with double `at()` calls

## Impact
Every JavaScript array, object literal, function parameter list, and TypeScript type now extracts the token kind fewer times during parsing.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: Boshen

crates/oxc_parser/src/cursor.rs

@@ -386,16 +386,25 @@ impl<'a> ParserImpl<'a> {
         F: Fn(&mut Self) -> T,
     {
         let mut list = self.ast.vec();
-        if self.at(close) || self.has_fatal_error() {
+        // Cache cur_kind() to avoid redundant calls in compound checks
+        let kind = self.cur_kind();
+        if kind == close
+            || matches!(kind, Kind::Eof | Kind::Undetermined)
+            || self.fatal_error.is_some()
+        {
             return (list, None);
         }
         list.push(f(self));
         loop {
-            if self.at(close) || self.has_fatal_error() {
+            let kind = self.cur_kind();
+            if kind == close
+                || matches!(kind, Kind::Eof | Kind::Undetermined)
+                || self.fatal_error.is_some()
+            {
                 return (list, None);
             }
             self.expect(separator);
-            if self.at(close) {
+            if self.cur_kind() == close {
                 let trailing_separator = self.prev_token_end - 1;
                 return (list, Some(trailing_separator));
             }

crates/oxc_parser/src/js/arrow.rs

@@ -65,7 +65,8 @@ impl<'a> ParserImpl<'a> {
             if self.cur_token().is_on_new_line() {
                 return Tristate::False;
             }
-            if !self.at(Kind::LParen) && !self.at(Kind::LAngle) {
+            let kind = self.cur_kind();
+            if kind != Kind::LParen && kind != Kind::LAngle {
                 return Tristate::False;
             }
         }

crates/oxc_parser/src/js/module.rs

@@ -98,12 +98,13 @@ impl<'a> ParserImpl<'a> {
                 self.error(diagnostics::escaped_keyword(token_after_import.span()));
             }
 
-            if self.at(Kind::LCurly) || self.at(Kind::Star) {
+            let kind = self.cur_kind();
+            if kind == Kind::LCurly || kind == Kind::Star {
                 // `import type { ...`
                 // `import type * ...`
                 import_kind = ImportOrExportKind::Type;
                 has_default_specifier = false;
-            } else if self.cur_kind().is_binding_identifier() {
+            } else if kind.is_binding_identifier() {
                 // `import type something ...`
                 let token = self.cur_token();
                 let identifier_after_type = self.parse_binding_identifier();

crates/oxc_parser/src/ts/types.rs

@@ -85,17 +85,17 @@ impl<'a> ParserImpl<'a> {
         if self.at(Kind::LAngle) {
             return true;
         }
-        if self.at(Kind::New) {
+        let kind = self.cur_kind();
+        if kind == Kind::New {
             return true;
         }
-        if !self.at(Kind::LParen) && !self.at(Kind::Abstract) {
+        if kind != Kind::LParen && kind != Kind::Abstract {
             return false;
         }
         let checkpoint = self.checkpoint();
-        let first = self.cur_kind();
         self.bump_any();
 
-        match first {
+        match kind {
             Kind::Abstract => {
                 // `abstract new ...`
                 if self.at(Kind::New) {
@@ -555,7 +555,8 @@ impl<'a> ParserImpl<'a> {
 
     fn is_start_of_mapped_type(&mut self) -> bool {
         self.bump_any();
-        if self.at(Kind::Plus) || self.at(Kind::Minus) {
+        let kind = self.cur_kind();
+        if kind == Kind::Plus || kind == Kind::Minus {
             self.bump_any();
             return self.at(Kind::Readonly);
         }
@@ -1184,7 +1185,8 @@ impl<'a> ParserImpl<'a> {
         let (key, computed) = self.parse_property_name();
         let optional = self.eat(Kind::Question);
 
-        if self.at(Kind::LParen) || self.at(Kind::LAngle) {
+        let kind = self.cur_kind();
+        if kind == Kind::LParen || kind == Kind::LAngle {
             for modifier in modifiers.iter() {
                 if modifier.kind == ModifierKind::Readonly {
                     self.error(