fix(rlc): resolve TYPE_CHECKING forward refs and unify caller_provided

`_resolve_param_models` now passes `self.model_classes` as `localns` to
`typing.get_type_hints()` so string annotations referencing
TYPE_CHECKING-only imports (e.g. `llm: 'LLM'`) resolve to actual classes
instead of being silently dropped. Adds `_eval_string_annotation` fallback
that evaluates string annotations against `func.__globals__` +
`model_classes` when `get_type_hints` still fails on nested third-party
ForwardRefs.

`_check_model_method` now treats all parameters as caller_provided
(consistent with `_check_coroutine`), not only `self`. Method parameters
with model relations are caller's preload contract; flagging them with
RLC003 was a false positive.

Together these surface previously-silent RLC007/RLC013 misses for
top-level functions whose post-commit forward-ref ORM access caused
MissingGreenlet at runtime.

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

Author: Foxerine

src/sqlmodel_ext/relation_load_checker.py

@@ -1093,8 +1093,15 @@ def _check_model_method(
         """
         Check a model method (with self tracking and @requires_relations parsing).
 
-        self is marked as caller_provided; pre-commit access skips RLC003.
-        But self.save() followed by relationship access still triggers RLC002.
+        All method parameters (``self`` plus other model-typed arguments) are marked
+        as caller_provided — these objects are passed in by the caller, preloading
+        is the caller's contract (typically declared via a docstring "preload before
+        calling: ..." note), so the method body must not be flagged with RLC003 for
+        "missing load=". This matches ``_check_coroutine``'s policy of marking all
+        params as caller_provided.
+
+        Post-commit relation access still triggers RLC002 / RLC007 / RLC008
+        (caller_provided does not exempt those checks).
         """
         # Parse AST to extract @requires_relations
         source_file, tree, line_offset = self._parse_function_source(func)
@@ -1114,17 +1121,19 @@ def _check_model_method(
         # Detect instance method or classmethod
         sig = python_inspect.signature(func)
         first_param = next(iter(sig.parameters), None)
-        caller_provided_params: set[str] = set()
 
         # cls -> class alias (classmethod's cls parameter doesn't enter tracked_vars,
         # only used for resolving class-level calls)
         class_aliases: dict[str, str] = {}
         if first_param == 'self':
             param_models['self'] = cls_name
-            caller_provided_params.add('self')
         elif first_param == 'cls':
             class_aliases['cls'] = cls_name
 
+        # All method params are caller-provided (self + other model-typed args
+        # are the caller's preload responsibility).
+        caller_provided_params: set[str] = set(param_models.keys())
+
         # @requires_relations declared rels as self's dep_loads
         dep_loads: dict[str, set[str]] = {}
         if 'self' in param_models and decorator_loads:
@@ -1287,20 +1296,32 @@ def _resolve_param_models(self, func: Any) -> dict[str, str]:
         (e.g. TYPE_CHECKING forward references), falls back to per-parameter
         ``__annotations__`` parsing to ensure resolvable params aren't missed.
 
+        TYPE_CHECKING forward reference handling: passes ``self.model_classes``
+        (all mapped ORM classes) as ``localns`` to ``get_type_hints()`` so that
+        string annotations like ``llm: 'LLM'`` (where ``LLM`` is imported only
+        under ``if TYPE_CHECKING:``) resolve to actual classes instead of being
+        silently dropped — silent drops cause RLC007/RLC013 false negatives.
+
         :returns: param_name -> model_class_name
         """
         param_models: dict[str, str] = {}
 
+        # Provide model_classes as localns so TYPE_CHECKING forward references resolve.
+        localns: dict[str, Any] = dict(self.model_classes)
         try:
-            hints = typing.get_type_hints(func, include_extras=True)
+            hints = typing.get_type_hints(func, include_extras=True, localns=localns)
         except Exception:
-            # get_type_hints may fail due to TYPE_CHECKING forward references.
-            # Fall back to per-parameter __annotations__ (skip unresolvable string annotations)
+            # Even with model_classes in scope, get_type_hints may still fail on
+            # nested third-party ForwardRefs. Fall back to per-parameter __annotations__:
+            # try to eval string annotations against globals + model_classes.
             hints = {}
             annotations: dict[str, Any] = getattr(func, '__annotations__', {})
             for param_name, annotation in annotations.items():
                 if isinstance(annotation, str):
-                    continue  # Skip unresolvable string annotations
+                    resolved = self._eval_string_annotation(annotation, func)
+                    if resolved is not None:
+                        hints[param_name] = resolved
+                    continue
                 hints[param_name] = annotation
 
         for param_name, hint in hints.items():
@@ -1333,6 +1354,24 @@ def _resolve_param_models(self, func: Any) -> dict[str, str]:
 
         return param_models
 
+    def _eval_string_annotation(self, annotation: str, func: Any) -> Any:
+        """
+        Evaluate a string annotation that ``typing.get_type_hints`` couldn't resolve.
+
+        Typical case: a TYPE_CHECKING-only import is referenced as a forward reference
+        (e.g. ``llm: 'LLM'`` where ``LLM`` is imported only under ``if TYPE_CHECKING:``).
+        Evaluates against ``func.__globals__`` merged with the known ORM model classes.
+
+        Supported forms: ``'LLM'``, ``'LLM | None'``, ``'list[LLM]'`` etc.
+        Returns ``None`` on failure (silent skip, matches the original fallback).
+        """
+        globalns: dict[str, Any] = getattr(func, '__globals__', {}) or {}
+        localns: dict[str, Any] = dict(self.model_classes)
+        try:
+            return eval(annotation, globalns, localns)  # noqa: S307 — source-code literal, scoped namespace
+        except Exception:
+            return None
+
     def _extract_model_from_hint(self, hint: Any) -> str | None:
         """
         Extract a model class name from a type annotation.