Remove async AST node variants for with, for, and def (#6369)

## Summary

Per the suggestion in
https://github.com/astral-sh/ruff/discussions/6183, this PR removes
`AsyncWith`, `AsyncFor`, and `AsyncFunctionDef`, replacing them with an
`is_async` field on the non-async variants of those structs. Unlike an
interpreter, we _generally_ have identical handling for these nodes, so
separating them into distinct variants adds complexity from which we
don't really benefit. This can be seen below, where we get to remove a
_ton_ of code related to adding generic `Any*` wrappers, and a ton of
duplicate branches for these cases.

## Test Plan

`cargo test` is unchanged, apart from parser snapshots.

crates/ruff_python_ast/src/comparable.rs

@@ -950,16 +950,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct StmtFunctionDef<'a> {
-    decorator_list: Vec<ComparableDecorator<'a>>,
-    name: &'a str,
-    type_params: Option<ComparableTypeParams<'a>>,
-    parameters: ComparableParameters<'a>,
-    returns: Option<ComparableExpr<'a>>,
-    body: Vec<ComparableStmt<'a>>,
-}
-
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub struct StmtAsyncFunctionDef<'a> {
+    is_async: bool,
     decorator_list: Vec<ComparableDecorator<'a>>,
     name: &'a str,
     type_params: Option<ComparableTypeParams<'a>>,
@@ -1084,14 +1075,7 @@ pub struct StmtAnnAssign<'a> {
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct StmtFor<'a> {
-    target: ComparableExpr<'a>,
-    iter: ComparableExpr<'a>,
-    body: Vec<ComparableStmt<'a>>,
-    orelse: Vec<ComparableStmt<'a>>,
-}
-
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub struct StmtAsyncFor<'a> {
+    is_async: bool,
     target: ComparableExpr<'a>,
     iter: ComparableExpr<'a>,
     body: Vec<ComparableStmt<'a>>,
@@ -1114,12 +1098,7 @@ pub struct StmtIf<'a> {
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct StmtWith<'a> {
-    items: Vec<ComparableWithItem<'a>>,
-    body: Vec<ComparableStmt<'a>>,
-}
-
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub struct StmtAsyncWith<'a> {
+    is_async: bool,
     items: Vec<ComparableWithItem<'a>>,
     body: Vec<ComparableStmt<'a>>,
 }
@@ -1194,7 +1173,6 @@ pub struct StmtLineMagic<'a> {
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum ComparableStmt<'a> {
     FunctionDef(StmtFunctionDef<'a>),
-    AsyncFunctionDef(StmtAsyncFunctionDef<'a>),
     ClassDef(StmtClassDef<'a>),
     Return(StmtReturn<'a>),
     Delete(StmtDelete<'a>),
@@ -1202,11 +1180,9 @@ pub enum ComparableStmt<'a> {
     AugAssign(StmtAugAssign<'a>),
     AnnAssign(StmtAnnAssign<'a>),
     For(StmtFor<'a>),
-    AsyncFor(StmtAsyncFor<'a>),
     While(StmtWhile<'a>),
     If(StmtIf<'a>),
     With(StmtWith<'a>),
-    AsyncWith(StmtAsyncWith<'a>),
     Match(StmtMatch<'a>),
     Raise(StmtRaise<'a>),
     Try(StmtTry<'a>),
@@ -1228,6 +1204,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
     fn from(stmt: &'a ast::Stmt) -> Self {
         match stmt {
             ast::Stmt::FunctionDef(ast::StmtFunctionDef {
+                is_async,
                 name,
                 parameters,
                 body,
@@ -1236,22 +1213,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
                 type_params,
                 range: _,
             }) => Self::FunctionDef(StmtFunctionDef {
-                name: name.as_str(),
-                parameters: parameters.into(),
-                body: body.iter().map(Into::into).collect(),
-                decorator_list: decorator_list.iter().map(Into::into).collect(),
-                returns: returns.as_ref().map(Into::into),
-                type_params: type_params.as_ref().map(Into::into),
-            }),
-            ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
-                name,
-                parameters,
-                body,
-                decorator_list,
-                returns,
-                type_params,
-                range: _,
-            }) => Self::AsyncFunctionDef(StmtAsyncFunctionDef {
+                is_async: *is_async,
                 name: name.as_str(),
                 parameters: parameters.into(),
                 body: body.iter().map(Into::into).collect(),
@@ -1320,24 +1282,14 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
                 simple: *simple,
             }),
             ast::Stmt::For(ast::StmtFor {
+                is_async,
                 target,
                 iter,
                 body,
                 orelse,
                 range: _,
             }) => Self::For(StmtFor {
-                target: target.into(),
-                iter: iter.into(),
-                body: body.iter().map(Into::into).collect(),
-                orelse: orelse.iter().map(Into::into).collect(),
-            }),
-            ast::Stmt::AsyncFor(ast::StmtAsyncFor {
-                target,
-                iter,
-                body,
-                orelse,
-                range: _,
-            }) => Self::AsyncFor(StmtAsyncFor {
+                is_async: *is_async,
                 target: target.into(),
                 iter: iter.into(),
                 body: body.iter().map(Into::into).collect(),
@@ -1364,18 +1316,12 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
                 elif_else_clauses: elif_else_clauses.iter().map(Into::into).collect(),
             }),
             ast::Stmt::With(ast::StmtWith {
+                is_async,
                 items,
                 body,
                 range: _,
             }) => Self::With(StmtWith {
-                items: items.iter().map(Into::into).collect(),
-                body: body.iter().map(Into::into).collect(),
-            }),
-            ast::Stmt::AsyncWith(ast::StmtAsyncWith {
-                items,
-                body,
-                range: _,
-            }) => Self::AsyncWith(StmtAsyncWith {
+                is_async: *is_async,
                 items: items.iter().map(Into::into).collect(),
                 body: body.iter().map(Into::into).collect(),
             }),