Raise syntax error for unparenthesized generator expr in multi-argument call (#12445)

## Summary

This PR fixes a bug to raise a syntax error when an unparenthesized
generator expression is used as an argument to a call when there are
more than one argument.

For reference, the grammar is:
```
primary:
    | ...
    | primary genexp 
    | primary '(' [arguments] ')' 
    | ...

genexp:
    | '(' ( assignment_expression | expression !':=') for_if_clauses ')' 
```

The `genexp` requires the parenthesis as mentioned in the grammar. So,
the grammar for a call expression is either a name followed by a
generator expression or a name followed by a list of argument. In the
former case, the parenthesis are excluded because the generator
expression provides them while in the later case, the parenthesis are
explicitly provided for a list of arguments which means that the
generator expression requires it's own parenthesis.

This was discovered in https://github.com/astral-sh/ruff/issues/12420.

## Test Plan

Add test cases for valid and invalid syntax.

Make sure that the parser from CPython also raises this at the parsing
step:
```console
$ python3.13 -m ast parser/_.py
  File "parser/_.py", line 1
    total(1, 2, x for x in range(5), 6)
                ^^^^^^^^^^^^^^^^^^^
SyntaxError: Generator expression must be parenthesized

$ python3.13 -m ast parser/_.py
  File "parser/_.py", line 1
    sum(x for x in range(10), 10)
        ^^^^^^^^^^^^^^^^^^^^
SyntaxError: Generator expression must be parenthesized
```

crates/ruff_python_parser/src/error.rs

@@ -106,6 +106,8 @@ pub enum ParseErrorType {
     UnparenthesizedNamedExpression,
     /// An unparenthesized tuple expression was found where it is not allowed.
     UnparenthesizedTupleExpression,
+    /// An unparenthesized generator expression was found where it is not allowed.
+    UnparenthesizedGeneratorExpression,
 
     /// An invalid usage of a lambda expression was found.
     InvalidLambdaExpressionUsage,
@@ -216,6 +218,9 @@ impl std::fmt::Display for ParseErrorType {
             ParseErrorType::UnparenthesizedTupleExpression => {
                 f.write_str("Unparenthesized tuple expression cannot be used here")
             }
+            ParseErrorType::UnparenthesizedGeneratorExpression => {
+                f.write_str("Unparenthesized generator expression cannot be used here")
+            }
             ParseErrorType::InvalidYieldExpressionUsage => {
                 f.write_str("Yield expression cannot be used here")
             }