Accept unparenthesized exception groups in except clauses

PEP 758, accepted for Python 3.14, allows `except A, B:` and
`except* A, B:` without parentheses when there is no `as` clause. The
parser rejects both today, so a file using the new form fails to parse
rather than producing a tree.

`GenericList` already collapses a single element to itself and wraps the
rest in a tuple, which is the shape CPython produces here, so this is one
production per clause. The `as` form is untouched: PEP 758 keeps
parentheses required there.

python.rs is regenerated with lalrpop 0.20.0, the version that produced
the file in tree. The diff is large because the state table renumbers.

Author: karpovantonme

parser/src/parser.rs

@@ -863,6 +863,24 @@ except OSError as e:
         insta::assert_debug_snapshot!(parse_ast);
     }
 
+    #[test]
+    fn test_try_unparenthesized_except_group() {
+        let parse_ast = ast::Suite::parse(
+            r#"try:
+    raise ValueError(1)
+except TypeError, OSError:
+    print('caught')
+
+try:
+    raise ExceptionGroup('eg', [KeyError()])
+except* KeyError, IndexError:
+    print('caught')"#,
+            "<test>",
+        )
+        .unwrap();
+        insta::assert_debug_snapshot!(parse_ast);
+    }
+
     #[test]
     fn test_try_star() {
         let parse_ast = ast::Suite::parse(

parser/src/python.lalrpop

@@ -878,7 +878,8 @@ TryStatement: ast::Stmt = {
 };
 
 ExceptStarClause: ast::ExceptHandler = {
-    <location:@L> "except" "*" <typ:Test<"all">> ":" <body:Suite> => {
+    // PEP 758 covers `except*` too.
+    <location:@L> "except" "*" <typ:GenericList<Test<"all">>> ":" <body:Suite> => {
         let end_location = body.last().unwrap().end();
         ast::ExceptHandler::ExceptHandler(
             ast::ExceptHandlerExceptHandler {
@@ -904,7 +905,11 @@ ExceptStarClause: ast::ExceptHandler = {
 
 
 ExceptClause: ast::ExceptHandler = {
-    <location:@L> "except" <typ:Test<"all">?> ":" <body:Suite> => {
+    // PEP 758: several exception types without parentheses, as long as there
+    // is no `as` clause. `GenericList` already collapses a single element to
+    // itself and wraps the rest in a tuple, which is exactly the shape CPython
+    // produces for `except A, B:`.
+    <location:@L> "except" <typ:GenericList<Test<"all">>?> ":" <body:Suite> => {
         let end_location = body.last().unwrap().end();
         ast::ExceptHandler::ExceptHandler(
             ast::ExceptHandlerExceptHandler {