fix(rlc): skip nested function definitions to eliminate yield false positives

AST default DFS recursed into nested ``def`` / ``async def`` bodies,
counting their yield/await as part of the outer function's flow.

Typical false positive:
    async def outer(...):
        async def _inner():
            yield chunk

The outer function has no yield, but _inner's yield was being counted
as the outer's, triggering RLC013 ("yield expires tracked vars").

Fix: override visit_FunctionDef / visit_AsyncFunctionDef as no-op so
nested function bodies are skipped under the current scope's analysis.

Trade-off: nested closures are not analyzed independently. In practice
nested closures rarely access ORM directly; analyzing them properly
would require a second pass with closure capture handling.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Foxerine

src/sqlmodel_ext/relation_load_checker.py

@@ -3422,6 +3422,33 @@ def visit_YieldFrom(self, node: ast.YieldFrom) -> None:
         if self.has_session_param:
             self._expire_all_tracked_vars_for_yield()
 
+    @override
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """
+        Do not recurse into nested function definitions.
+
+        AST default DFS would descend into nested ``def`` bodies and count
+        their yield/await statements as part of the outer function's flow,
+        producing false positives. Nested function bodies execute in their
+        own scope when invoked, not as part of the outer flow.
+
+        Typical false positive:
+            ``async def outer(...):
+                async def _inner():
+                    yield chunk``
+        The outer function has no yield, but ``_inner``'s yield was being
+        counted as the outer's, triggering RLC013.
+
+        Trade-off: nested closures are not analyzed under the current
+        scope. Independently scanning them would require a second pass
+        with closure capture analysis; in practice nested closures rarely
+        access ORM directly, so we accept the gap.
+        """
+
+    @override
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Do not recurse into nested async function definitions (same as visit_FunctionDef)."""
+
     # ========================= Branch-aware state management =========================
 
     def _snapshot_tracked_vars(self) -> dict[str, _TrackedVar]: