[syntax-errors] Single starred assignment target (#17024)

Summary
--

Detects starred assignment targets outside of tuples and lists like `*a
= (1,)`.

This PR only considers assignment statements. I also checked annotated
assigment statements, but these give a separate error that we already
catch, so I think they're okay not to consider:

```pycon
>>> *a: list[int] = []
  File "<python-input-72>", line 1
    *a: list[int] = []
      ^
SyntaxError: invalid syntax
```

Fixes #13759

Test Plan
--

New inline tests, plus a new `SemanticSyntaxError` for an existing
parser test. I also removed a now-invalid case from an otherwise-valid
test fixture.

The new semantic error leads to two errors for the case below:

```python
*foo() = 42
```

but this matches [pyright] too.

[pyright]: https://pyright-play.net/?code=FQMw9mAUCUAEC8sAsAmAUEA

crates/ruff_python_parser/src/semantic_errors.rs

@@ -73,6 +73,22 @@ impl SemanticSyntaxChecker {
                     Self::duplicate_type_parameter_name(type_params, ctx);
                 }
             }
+            Stmt::Assign(ast::StmtAssign { targets, .. }) => {
+                if let [Expr::Starred(ast::ExprStarred { range, .. })] = targets.as_slice() {
+                    // test_ok single_starred_assignment_target
+                    // (*a,) = (1,)
+                    // *a, = (1,)
+                    // [*a] = (1,)
+
+                    // test_err single_starred_assignment_target
+                    // *a = (1,)
+                    Self::add_error(
+                        ctx,
+                        SemanticSyntaxErrorKind::SingleStarredAssignment,
+                        *range,
+                    );
+                }
+            }
             _ => {}
         }
 
@@ -437,6 +453,9 @@ impl Display for SemanticSyntaxError {
                     f.write_str("wildcard makes remaining patterns unreachable")
                 }
             },
+            SemanticSyntaxErrorKind::SingleStarredAssignment => {
+                f.write_str("starred assignment target must be in a list or tuple")
+            }
             SemanticSyntaxErrorKind::WriteToDebug(kind) => match kind {
                 WriteToDebugKind::Store => f.write_str("cannot assign to `__debug__`"),
                 WriteToDebugKind::Delete(python_version) => {
@@ -522,6 +541,23 @@ pub enum SemanticSyntaxErrorKind {
     /// [Python reference]: https://docs.python.org/3/reference/compound_stmts.html#irrefutable-case-blocks
     IrrefutableCasePattern(IrrefutablePatternKind),
 
+    /// Represents a single starred assignment target outside of a tuple or list.
+    ///
+    /// ## Examples
+    ///
+    /// ```python
+    /// *a = (1,)  # SyntaxError
+    /// ```
+    ///
+    /// A starred assignment target can only occur within a tuple or list:
+    ///
+    /// ```python
+    /// b, *a = 1, 2, 3
+    /// (*a,) = 1, 2, 3
+    /// [*a] = 1, 2, 3
+    /// ```
+    SingleStarredAssignment,
+
     /// Represents a write to `__debug__`. This includes simple assignments and deletions as well
     /// other kinds of statements that can introduce bindings, such as type parameters in functions,
     /// classes, and aliases, `match` arms, and imports, among others.