Fix false positive in for mutations in return statements (B909) (#18408)

<!--
Thank you for contributing to Ruff/ty! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title? (Please prefix
with `[ty]` for ty pull
  requests.)
- Does this pull request include references to any relevant issues?
-->

## Summary

Fixes false positive in B909 (`loop-iterator-mutation`) where mutations
inside return/break statements were incorrectly flagged as violations.
The fix adds tracking for when mutations occur within return/break
statements and excludes them from violation detection, as they don't
cause the iteration issues B909 is designed to prevent.



## Test Plan

- Added test cases covering the reported false positive scenarios to
`B909.py`
  - Verified existing B909 tests continue to pass (no regressions)
  - Ran `cargo test -p ruff_linter --lib flake8_bugbear` successfully

Fixes #18399

crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B909.py

@@ -179,3 +179,17 @@ def func():
     for elem in some_list:
         if some_list.pop() == 2:
             return
+
+# should not error - direct return with mutation (Issue #18399)
+def fail_map(mapping):
+    for key in mapping:
+        return mapping.pop(key)
+
+def success_map(mapping):
+    for key in mapping:
+        ret = mapping.pop(key)  # should not error
+        return ret
+
+def fail_list(seq):
+    for val in seq:
+        return seq.pop(4)

crates/ruff_linter/src/rules/flake8_bugbear/rules/loop_iterator_mutation.rs

@@ -293,7 +293,6 @@ impl<'a> Visitor<'a> for LoopMutationsVisitor<'a> {
                 if let Some(mutations) = self.mutations.get_mut(&self.branch) {
                     mutations.clear();
                 }
-                visitor::walk_stmt(self, stmt);
             }
 
             // Avoid recursion for class and function definitions.