Review follow-up for pytorch#198124.

forward. UnspecializedNNModuleVariable.call_function short-circuits
_call_impl to forward and built it with a plain UserFunctionVariable,
explicitly to skip the forward.__code__ guard; the rationale was the ~20%
guard overhead from pytorch#124975. That left `model(x)` reusing a stale graph
after `Model.forward.__code__ = ...` or `Model.forward = other`, while a
helper that forward calls was guarded, which is the inconsistency the review
pointed out. The short-circuit now uses create_with_source on the
type(mod).__dict__ source when the target is forward. This is not the
pytorch#124975 trade-off: that change put an ID_MATCH on every inlined function,
whereas this is one CLOSURE_MATCH per (class, method), deduped by the
get_source_by_walking_mro cache, so a model built from N copies of a block
pays once per block class, not per instance. Instance-level patching is
still handled by guard_to_detect_forward_monkeypatching, whose comment now
says where class-level patching is caught.

classmethod. Main reworked ClassMethodVariable while this was in review:
from_descriptor now builds the wrapped function with VariableTracker.build
on the __func__ source, which installs the code guard itself. The merge
takes main's version, and test_classmethod_code_mutation_recompiles passes
on main without this PR, so that half of the original change is gone.

Other sites. object_protocol.py's FunctionType branch sources the function
as obj.<name>.__func__, a GetAttr chain off the instance, which is the
tag-unsafe shape this change already leaves unguarded on the TypeSource
fallback, so it is left alone. The dunder helpers that use
AttrSource(TypeSource(...)) are the same case.

Cleanup: the resolve_type_attr comment is down to two lines, and the
TypeSource fallback source is built inline in the else branch, where it is
the only use.

Known limit: with the opt-in use_recursive_dict_tags_for_guards, a tag-safe
root skips its subtree while its dict tag is unchanged, so an in-place
__code__ swap is still missed there. That applies to every CLOSURE_MATCH
under such a root, predates this change, and the flag is off by default.

Tests:
- test_nn_module_method_mutation_recompiles (4): forward vs. a helper it
  calls, __code__ replacement vs. rebinding, through `mod(x)`.
- test_nn_module_tag_safe_with_method_code_guard: a module reaching both
  guarded paths stays a tag-safe root.

Test Plan:

Run against the 2.15.0.dev20261003 CPU nightly (which matches origin/main
for every file touched here) with this branch's torch/_dynamo files laid
over it:

```
python test/dynamo/test_recompiles.py
python test/dynamo/test_guard_manager.py
```

All pass. Without the change, the four existing class-function mutation
tests and the four new nn.Module ones fail with a stale result.

```
pytest test/dynamo/test_modules.py test/dynamo/test_functions.py
    test/dynamo/test_guard_exclusion.py test/dynamo/test_autograd_function.py
```

943 passed, 3 failed: test_torch_function_metadata_attrs_constant,
test_inject_module_parameters and test_save_and_load_inductor. All three fail
the same way on the unpatched nightly (Windows environment), so none is from
this change.

This change was authored with the assistance of an AI coding agent.

Review follow-up for pytorch#198124.

CI on aef3192 failed test_aot_compile_module (PackageError: CLOSURE_MATCH
guard cannot be serialized) and, on six shards,
test_precompile_session_captures_variants_and_summarizes (one risky dropped
guard). The code guard this PR adds on type(obj).__dict__[name] is
local-rooted, so skip_guard_on_globals_unsafe keeps it, and at that merge
base serialize_guards refused every CLOSURE_MATCH; precompile's default
filter dropped it and, with the slot holding different functions across
variants, flagged the drop as risky. The automated review pointed out the
same exposure for any method call on a user object through
resolve_type_attr.

Main has since fixed this at the shared point. pytorch#198810 rewrites a
CLOSURE_MATCH on a plain function into FUNCTION_CODE_MATCH (code object plus
the globals' module, compared by value) when guards are saved, and
is_portable_function_guard lets precompile's default filter keep it. That
covers the forward guard and the resolve_type_attr guard alike, so this
branch is rebased onto main (taking main's ClassMethodVariable in the
functions.py conflict, as the earlier merge did) and needs no source change.
A method whose globals no importable module owns (e.g. a class built by
exec) is still refused, which is main's policy for every CLOSURE_MATCH.

New test, test_aot_compile_user_method_code_guard: aot_compile a function
calling a method on a user object with skip_guard_on_globals_unsafe, save,
load, check the result, then replace the method's __code__ and check that
the loaded artifact's guard fails. Without this PR the last check fails
(nothing guards the code); at the old merge base the compile itself raises
the PackageError.

Test Plan:

Linux (WSL Ubuntu 22.04), Python 3.12, 2.16.0.dev20261016 CPU nightly
(built from 99096b2, 41 commits behind origin/main), with every torch/*.py
that differs between that commit and this branch laid over it.

Reproduction on the old base: 2.15.0.dev20261004 nightly (e8f41c0 + 3
non-dynamo commits) with aef3192's nn_module.py and user_defined.py: both CI
tests fail as reported (PackageError; risky_dropped_guards 1 != 0), and pass
without the two files. A user-object method aot_compile with
skip_guard_on_globals_unsafe raises the same PackageError with them and
compiles without them.

After rebase:

```
pytest test/dynamo/test_recompiles.py test/dynamo/test_guard_manager.py
    test/dynamo/test_aot_compile.py test/dynamo/test_precompile_package.py
    test/dynamo/test_modules.py test/dynamo/test_functions.py
    test/dynamo/test_guard_exclusion.py test/dynamo/test_autograd_function.py
    test/dynamo/test_guard_serialization.py test/dynamo/test_package.py
```

1889 passed, 1 failed:
test_nested_function_preserves_a_guarded_defaults_tuple, which fails the
same way with origin/main's torch files, so it is not from this change. With
origin/main's torch files the same run also fails the eight mutation tests
in test_recompiles.py and the new aot test.

This change was authored with the assistance of an AI coding agent.