[syntax-errors] Star annotations before Python 3.11 (#16545)

Summary
--

This is closely related to (and stacked on)
https://github.com/astral-sh/ruff/pull/16544 and detects star
annotations in function definitions.

I initially called the variant `StarExpressionInAnnotation` to mirror
`StarExpressionInIndex`, but I realized it's not really a "star
expression" in this position and renamed it. `StarAnnotation` seems in
line with the PEP.

Test Plan
--

Two new inline tests. It looked like there was pretty good existing
coverage of this syntax, so I just added simple examples to test the
version cutoff.

crates/ruff_python_parser/src/error.rs

@@ -644,6 +644,34 @@ pub enum UnsupportedSyntaxErrorKind {
     ///
     /// [PEP 646]: https://peps.python.org/pep-0646/#change-1-star-expressions-in-indexes
     StarExpressionInIndex,
+
+    /// Represents the use of a [PEP 646] star annotations in a function definition.
+    ///
+    /// ## Examples
+    ///
+    /// Before Python 3.11, star annotations were not allowed in function definitions. This
+    /// restriction was lifted in [PEP 646] to allow type annotations for `typing.TypeVarTuple`,
+    /// also added in Python 3.11:
+    ///
+    /// ```python
+    /// from typing import TypeVarTuple
+    ///
+    /// Ts = TypeVarTuple('Ts')
+    ///
+    /// def foo(*args: *Ts): ...
+    /// ```
+    ///
+    /// Unlike [`UnsupportedSyntaxErrorKind::StarExpressionInIndex`], this does not include any
+    /// other annotation positions:
+    ///
+    /// ```python
+    /// x: *Ts                # Syntax error
+    /// def foo(x: *Ts): ...  # Syntax error
+    /// ```
+    ///
+    /// [PEP 646]: https://peps.python.org/pep-0646/#change-2-args-as-a-typevartuple
+    StarAnnotation,
+
     /// Represents the use of tuple unpacking in a `for` statement iterator clause before Python
     /// 3.9.
     ///
@@ -699,6 +727,7 @@ impl Display for UnsupportedSyntaxError {
             UnsupportedSyntaxErrorKind::StarExpressionInIndex => {
                 "Cannot use star expression in index"
             }
+            UnsupportedSyntaxErrorKind::StarAnnotation => "Cannot use star annotation",
             UnsupportedSyntaxErrorKind::UnparenthesizedUnpackInFor => {
                 "Cannot use iterable unpacking in `for` statements"
             }
@@ -750,6 +779,7 @@ impl UnsupportedSyntaxErrorKind {
             UnsupportedSyntaxErrorKind::StarExpressionInIndex => {
                 Change::Added(PythonVersion::PY311)
             }
+            UnsupportedSyntaxErrorKind::StarAnnotation => Change::Added(PythonVersion::PY311),
             UnsupportedSyntaxErrorKind::UnparenthesizedUnpackInFor => {
                 Change::Added(PythonVersion::PY39)
             }

crates/ruff_python_parser/src/parser/statement.rs

@@ -2882,9 +2882,23 @@ impl<'src> Parser<'src> {
                             // def foo(*args: *int or str): ...
                             // def foo(*args: *yield x): ...
                             // # def foo(*args: **int): ...
-                            self.parse_conditional_expression_or_higher_impl(
+                            let parsed_expr = self.parse_conditional_expression_or_higher_impl(
                                 ExpressionContext::starred_bitwise_or(),
-                            )
+                            );
+
+                            // test_ok param_with_star_annotation_py311
+                            // # parse_options: {"target-version": "3.11"}
+                            // def foo(*args: *Ts): ...
+
+                            // test_err param_with_star_annotation_py310
+                            // # parse_options: {"target-version": "3.10"}
+                            // def foo(*args: *Ts): ...
+                            self.add_unsupported_syntax_error(
+                                UnsupportedSyntaxErrorKind::StarAnnotation,
+                                parsed_expr.range(),
+                            );
+
+                            parsed_expr
                         }
                         AllowStarAnnotation::No => {
                             // test_ok param_with_annotation