Make Parameters an optional field on ExprLambda (#6669)

## Summary

If a lambda doesn't contain any parameters, or any parameter _tokens_
(like `*`), we can use `None` for the parameters. This feels like a
better representation to me, since, e.g., what should the `TextRange` be
for a non-existent set of parameters? It also allows us to remove
several sites where we check if the `Parameters` is empty by seeing if
it contains any arguments, so semantically, we're already trying to
detect and model around this elsewhere.

Changing this also fixes a number of issues with dangling comments in
parameter-less lambdas, since those comments are now automatically
marked as dangling on the lambda. (As-is, we were also doing something
not-great whereby the lambda was responsible for formatting dangling
comments on the parameters, which has been removed.)

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

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

## Test Plan

`cargo test`

crates/ruff_python_formatter/src/comments/placement.rs

@@ -162,9 +162,14 @@ fn handle_enclosed_comment<'a>(
     locator: &Locator,
 ) -> CommentPlacement<'a> {
     match comment.enclosing_node() {
-        AnyNodeRef::Parameters(arguments) => {
-            handle_parameters_separator_comment(comment, arguments, locator)
-                .or_else(|comment| handle_bracketed_end_of_line_comment(comment, locator))
+        AnyNodeRef::Parameters(parameters) => {
+            handle_parameters_separator_comment(comment, parameters, locator).or_else(|comment| {
+                if are_parameters_parenthesized(parameters, locator.contents()) {
+                    handle_bracketed_end_of_line_comment(comment, locator)
+                } else {
+                    CommentPlacement::Default(comment)
+                }
+            })
         }
         AnyNodeRef::Arguments(_) | AnyNodeRef::TypeParams(_) => {
             handle_bracketed_end_of_line_comment(comment, locator)
@@ -1544,6 +1549,13 @@ fn is_first_statement_in_alternate_body(statement: AnyNodeRef, has_body: AnyNode
     }
 }
 
+/// Returns `true` if the parameters are parenthesized (as in a function definition), or `false` if
+/// not (as in a lambda).
+fn are_parameters_parenthesized(parameters: &Parameters, contents: &str) -> bool {
+    // A lambda never has parentheses around its parameters, but a function definition always does.
+    contents[parameters.range()].starts_with('(')
+}
+
 /// Counts the number of empty lines in `contents`.
 fn max_empty_lines(contents: &str) -> u32 {
     let mut newlines = 0u32;