Introduce an Arguments AST node for function calls and class definitions (#6259)

## Summary

This PR adds a new `Arguments` AST node, which we can use for function
calls and class definitions.

The `Arguments` node spans from the left (open) to right (close)
parentheses inclusive.

In the case of classes, the `Arguments` is an option, to differentiate
between:

```python
# None
class C: ...

# Some, with empty vectors
class C(): ...
```

In this PR, we don't really leverage this change (except that a few
rules get much simpler, since we don't need to lex to find the start and
end ranges of the parentheses, e.g.,
`crates/ruff/src/rules/pyupgrade/rules/lru_cache_without_parameters.rs`,
`crates/ruff/src/rules/pyupgrade/rules/unnecessary_class_parentheses.rs`).

In future PRs, this will be especially helpful for the formatter, since
we can track comments enclosed on the node itself.

## Test Plan

`cargo test`

crates/ruff_python_formatter/src/expression/expr_call.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{Expr, ExprCall, Ranged};
+use ruff_python_ast::{Arguments, Expr, ExprCall, Ranged};
 use ruff_text_size::{TextRange, TextSize};
 
 use crate::builders::empty_parenthesized_with_dangling_comments;
@@ -21,8 +21,12 @@ impl FormatNodeRule<ExprCall> for FormatExprCall {
         let ExprCall {
             range: _,
             func,
-            args,
-            keywords,
+            arguments:
+                Arguments {
+                    args,
+                    keywords,
+                    range: _,
+                },
         } = item;
 
         // We have a case with `f()` without any argument, which is a special case because we can

crates/ruff_python_formatter/src/expression/mod.rs

@@ -356,8 +356,7 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> {
             Expr::Call(ast::ExprCall {
                 range: _,
                 func,
-                args: _,
-                keywords: _,
+                arguments: _,
             }) => {
                 self.any_parenthesized_expressions = true;
                 // Only walk the function, the arguments are always parenthesized

crates/ruff_python_formatter/src/statement/stmt_class_def.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{Ranged, StmtClassDef};
+use ruff_python_ast::{Arguments, Ranged, StmtClassDef};
 use ruff_text_size::TextRange;
 
 use ruff_formatter::write;
@@ -17,8 +17,7 @@ impl FormatNodeRule<StmtClassDef> for FormatStmtClassDef {
         let StmtClassDef {
             range: _,
             name,
-            bases,
-            keywords,
+            arguments,
             body,
             type_params: _,
             decorator_list,
@@ -34,7 +33,12 @@ impl FormatNodeRule<StmtClassDef> for FormatStmtClassDef {
 
         write!(f, [text("class"), space(), name.format()])?;
 
-        if !(bases.is_empty() && keywords.is_empty()) {
+        if arguments
+            .as_ref()
+            .is_some_and(|Arguments { args, keywords, .. }| {
+                !(args.is_empty() && keywords.is_empty())
+            })
+        {
             parenthesized(
                 "(",
                 &FormatInheritanceClause {
@@ -75,12 +79,19 @@ struct FormatInheritanceClause<'a> {
 impl Format<PyFormatContext<'_>> for FormatInheritanceClause<'_> {
     fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
         let StmtClassDef {
-            bases,
-            keywords,
+            arguments:
+                Some(Arguments {
+                    args: bases,
+                    keywords,
+                    ..
+                }),
             name,
             body,
             ..
-        } = self.class_definition;
+        } = self.class_definition
+        else {
+            return Ok(());
+        };
 
         let source = f.context().source();