[pyupgrade] Avoid converting format calls with more kinds of side effects (UP032) (#25484)

## Summary

Fixes part of #15874: UP032 unsoundly converted str.format calls that
repeat a side-effecting argument. The check only
caught calls, so a repeated d[k] or walrus slipped through. Switch it to
contains_effect.

## Test Plan

New mdtest at crates/ruff_linter/resources/mdtest/pyupgrade/f-string.md.

---------

Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>

Author: anishgirianish

crates/ruff_linter/resources/mdtest/pyupgrade/f-string.md

@@ -0,0 +1,51 @@
+# `f-string` (`UP032`)
+
+```toml
+lint.select = ["UP032"]
+```
+
+## Repeated arguments with side effects
+
+A `str.format` argument is evaluated once, but an f-string re-evaluates it on every interpolation. So
+when an argument is used more than once and can have a side effect, the call is left unconverted to
+avoid running that side effect twice. This used to cover only call expressions; it now covers any
+side-effecting expression, such as a subscript or a walrus binding. Even a builtin call like `list()`
+counts, since the f-string would construct a new object on each interpolation.
+
+```py
+def foo(): ...
+
+
+d = {}
+
+"{x} {x}".format(x=foo())
+"{x} {x}".format(x=d["k"])
+"{x} {x}".format(x=(y := 1))
+"{x.append} {x.append}".format(x=list())
+```
+
+## A single use is still converted
+
+When the argument is interpolated once, the side effect runs once either way, so the fix is safe.
+
+```py
+def foo(): ...
+
+
+"{x}".format(x=foo())  # snapshot: f-string
+```
+
+```snapshot
+error[UP032]: Use f-string instead of `format` call
+ --> src/mdtest_snippet.py:4:1
+  |
+4 | "{x}".format(x=foo())  # snapshot: f-string
+  | ^^^^^^^^^^^^^^^^^^^^^
+  |
+help: Convert to f-string
+1 | def foo(): ...
+2 |
+3 |
+  - "{x}".format(x=foo())  # snapshot: f-string
+4 + f"{foo()}"  # snapshot: f-string
+```

crates/ruff_linter/src/rules/pyupgrade/rules/f_strings.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::helpers::any_over_expr;
+use ruff_python_ast::helpers::contains_effect;
 use ruff_python_ast::str::{leading_quote, trailing_quote};
 use ruff_python_ast::token::TokenKind;
 use ruff_python_ast::{self as ast, Expr, Keyword, StringFlags};
@@ -327,10 +327,11 @@ impl FStringConversion {
                     // string, we can't convert the format string to an f-string. For example,
                     // converting `"{x} {x}".format(x=foo())` would result in `f"{foo()} {foo()}"`,
                     // which would call `foo()` twice.
-                    if !seen.insert(specifier) {
-                        if any_over_expr(arg, &Expr::is_call_expr) {
-                            return Ok(Self::SideEffects);
-                        }
+                    //
+                    // This is also true for builtins, so we don't treat them as special when
+                    // checking for effects here.
+                    if !seen.insert(specifier) && contains_effect(arg, |_| false) {
+                        return Ok(Self::SideEffects);
                     }
 
                     converted.push_str(&formatted_expr(