Compare formatted and unformatted ASTs during formatter tests (#8624)

## Summary

This PR implements validation in the formatter tests to ensure that we
don't modify the AST during formatting. Black has similar logic.

In implementing this, I learned that Black actually _does_ modify the
AST, and their test infrastructure normalizes the AST to wipe away those
differences. Specifically, Black changes the indentation of docstrings,
which _does_ modify the AST; and it also inserts parentheses in `del`
statements, which changes the AST too.

Ruff also does both these things, so we _also_ implement the same
normalization using a new visitor that allows for modifying the AST.

Closes https://github.com/astral-sh/ruff/issues/8184.

## Test Plan

`cargo test`

crates/ruff_python_formatter/tests/normalizer.rs

@@ -0,0 +1,83 @@
+use itertools::Either::{Left, Right};
+
+use ruff_python_ast::visitor::transformer;
+use ruff_python_ast::visitor::transformer::Transformer;
+use ruff_python_ast::{self as ast, Expr, Stmt};
+
+/// A struct to normalize AST nodes for the purpose of comparing formatted representations for
+/// semantic equivalence.
+///
+/// Vis-à-vis comparing ASTs, comparing these normalized representations does the following:
+/// - Ignores non-abstraction information that we've encoded into the AST, e.g., the difference
+///   between `class C: ...` and `class C(): ...`, which is part of our AST but not `CPython`'s.
+/// - Normalize strings. The formatter can re-indent docstrings, so we need to compare string
+///   contents ignoring whitespace. (Black does the same.)
+/// - Ignores nested tuples in deletions. (Black does the same.)
+pub(crate) struct Normalizer;
+
+impl Normalizer {
+    /// Transform an AST module into a normalized representation.
+    #[allow(dead_code)]
+    pub(crate) fn visit_module(&self, module: &mut ast::Mod) {
+        match module {
+            ast::Mod::Module(module) => {
+                self.visit_body(&mut module.body);
+            }
+            ast::Mod::Expression(expression) => {
+                self.visit_expr(&mut expression.body);
+            }
+        }
+    }
+}
+
+impl Transformer for Normalizer {
+    fn visit_stmt(&self, stmt: &mut Stmt) {
+        match stmt {
+            Stmt::ClassDef(class_def) => {
+                // Treat `class C: ...` and `class C(): ...` equivalently.
+                if class_def
+                    .arguments
+                    .as_ref()
+                    .is_some_and(|arguments| arguments.is_empty())
+                {
+                    class_def.arguments = None;
+                }
+            }
+            Stmt::Delete(delete) => {
+                // Treat `del a, b` and `del (a, b)` equivalently.
+                delete.targets = delete
+                    .targets
+                    .clone()
+                    .into_iter()
+                    .flat_map(|target| {
+                        if let Expr::Tuple(tuple) = target {
+                            Left(tuple.elts.into_iter())
+                        } else {
+                            Right(std::iter::once(target))
+                        }
+                    })
+                    .collect();
+            }
+            _ => {}
+        }
+
+        transformer::walk_stmt(self, stmt);
+    }
+
+    fn visit_expr(&self, expr: &mut Expr) {
+        if let Expr::StringLiteral(string_literal) = expr {
+            // Normalize a string by (1) stripping any leading and trailing space from each
+            // line, and (2) removing any blank lines from the start and end of the string.
+            string_literal.value = string_literal
+                .value
+                .lines()
+                .map(str::trim)
+                .collect::<Vec<_>>()
+                .join("\n")
+                .trim()
+                .to_owned();
+        }
+
+        transformer::walk_expr(self, expr);
+    }
+}