Add parsing of type alias statements i.e. the type keyword (RustPython#97)

Extends RustPython#95
Closes RustPython#82 

Adds parsing of new `type` soft keyword for defining type aliases.

Supports type alias statements as defined in PEP 695 e.g. 

```python
# A non-generic type alias
type IntOrStr = int | str

# A generic type alias
type ListOrSet[T] = list[T] | set[T]

# A type alias that includes a forward reference
type AnimalOrVegetable = Animal | "Vegetable"

# A generic self-referential type alias
type RecursiveList[T] = T | list[RecursiveList[T]]
```

All type parameter kinds are supported as in RustPython#95.

Builds on soft keyword abstractions introduced in RustPython/RustPython#4519

Author: zanieb

parser/build.rs

@@ -154,6 +154,7 @@ fn gen_phf(out_dir: &Path) {
         .entry("raise", "Tok::Raise")
         .entry("return", "Tok::Return")
         .entry("try", "Tok::Try")
+        .entry("type", "Tok::Type")
         .entry("while", "Tok::While")
         .entry("with", "Tok::With")
         .entry("yield", "Tok::Yield")

parser/src/parser.rs

@@ -894,11 +894,92 @@ except* OSError as e:
         assert!(parse(source, Mode::Interactive, "<embedded>").is_ok());
     }
 
+    #[test]
+    #[cfg(feature = "all-nodes-with-ranges")]
+    fn test_parse_type_declaration() {
+        let source = r#"
+type X = int
+type X = int | str
+type X = int | "ForwardRefY"
+type X[T] = T | list[X[T]]  # recursive
+type X[T] = int
+type X[T] = list[T] | set[T]
+type X[T, *Ts, **P] = (T, Ts, P)
+type X[T: int, *Ts, **P] = (T, Ts, P)
+type X[T: (int, str), *Ts, **P] = (T, Ts, P)
+
+# soft keyword as alias name
+type type = int  
+type match = int
+type case = int
+
+# soft keyword as value
+type foo = type
+type foo = match
+type foo = case
+
+# multine definitions
+type \
+	X = int
+type X \
+	= int
+type X = \
+	int
+type X = (
+    int
+)
+type \
+    X[T] = T
+type X \
+    [T] = T
+type X[T] \
+    = T
+"#;
+        insta::assert_debug_snapshot!(ast::Suite::parse(source, "<test>").unwrap());
+    }
+
+    #[test]
+    #[cfg(feature = "all-nodes-with-ranges")]
+    fn test_type_as_identifier() {
+        let source = r#"\
+type *a + b, c   # ((type * a) + b), c
+type *(a + b), c   # (type * (a + b)), c
+type (*a + b, c)   # type ((*(a + b)), c)
+type -a * b + c   # (type - (a * b)) + c
+type -(a * b) + c   # (type - (a * b)) + c
+type (-a) * b + c   # (type (-(a * b))) + c
+type ().a   # (type()).a
+type (()).a   # (type(())).a
+type ((),).a   # (type(())).a
+type [a].b   # (type[a]).b
+type [a,].b   # (type[(a,)]).b  (not (type[a]).b)
+type [(a,)].b   # (type[(a,)]).b
+type()[a:
+    b]  # (type())[a: b]
+if type := 1: pass
+type = lambda query: query == event
+print(type(12))
+type(type)
+a = (
+	type in C
+)
+a = (
+	type(b)
+)
+type (
+	X = int
+)
+type = 1
+type = x = 1
+x = type = 1
+"#;
+        insta::assert_debug_snapshot!(ast::Suite::parse(source, "<test>").unwrap());
+    }
+
     #[test]
     #[cfg(feature = "all-nodes-with-ranges")]
     fn test_match_as_identifier() {
-        let parse_ast = ast::Suite::parse(
-            r#"
+        let source = r#"\
 match *a + b, c   # ((match * a) + b), c
 match *(a + b), c   # (match * (a + b)), c
 match (*a + b, c)   # match ((*(a + b)), c)
@@ -920,11 +1001,8 @@ match match:
         pass
 match = lambda query: query == event
 print(match(12))
-"#,
-            "<test>",
-        )
-        .unwrap();
-        insta::assert_debug_snapshot!(parse_ast);
+"#;
+        insta::assert_debug_snapshot!(ast::Suite::parse(source, "<test>").unwrap());
     }
 
     #[test]

parser/src/python.lalrpop

@@ -86,6 +86,7 @@ SmallStatement: ast::Stmt = {
     GlobalStatement,
     NonlocalStatement,
     AssertStatement,
+    TypeAliasStatement,
 };
 
 PassStatement: ast::Stmt = {
@@ -978,6 +979,25 @@ FuncDef: ast::Stmt = {
     },
 };
 
+TypeAliasName: ast::Expr = {
+    <location:@L> <name:Identifier> <end_location:@R> => ast::Expr::Name(
+        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+    ),
+}
+
+TypeAliasStatement: ast::Stmt = {
+    <location:@L> "type" <name:TypeAliasName> <type_params:TypeParamList?> "=" <value:Test<"all">> <end_location:@R> => {
+        ast::Stmt::TypeAlias(
+            ast::StmtTypeAlias {
+                name: Box::new(name),
+                value: Box::new(value),
+                type_params: type_params.unwrap_or_default(),
+                range: (location..end_location).into()
+            },
+        )
+    },
+};
+
 Parameters: ast::Arguments = {
     <location:@L> "(" <a: (ParameterList<TypedParameter, StarTypedParameter, DoubleStarTypedParameter>)?> ")" <end_location:@R> =>? {
         a.as_ref().map(validate_arguments).transpose()?;
@@ -1750,6 +1770,7 @@ extern {
         "raise" => token::Tok::Raise,
         "return" => token::Tok::Return,
         "try" => token::Tok::Try,
+        "type" => token::Tok::Type,
         "while" => token::Tok::While,
         "match" => token::Tok::Match,
         "case" => token::Tok::Case,