feat(aot): AOT/trim annotations on dependency-search surface + NativeAOT smoke

[Rolling2405]

Summary

Adds [RequiresUnreferencedCode] and [RequiresDynamicCode] annotations to the dependency-search (Tier 2) public API surface, gated #if NET10_0_OR_GREATER, so that consumers targeting NativeAOT or the trimmer receive clear, actionable warnings at their call sites instead of opaque linker errors deep in Mono.Cecil.

Also includes a NativeAOT publish smoke test (tests/NetArchTest.AotSmoke) that proves the Tier 1 surface (type loading + name/namespace/structural predicates) compiles clean under PublishAot=true /warnaserror on net10.0-windows.

netstandard2.0 is fully preserved — all annotations are #if NET10_0_OR_GREATER guarded. No public API shape change on netstandard2.0.

Intentional scope

Tier	Description	This PR
1	Types.FromPath / name / namespace / structural predicates	✅ Smoke-tested, zero IL warnings
2	Dependency-search predicates	✅ Annotated with [RequiresUnreferencedCode] / [RequiresDynamicCode]
3	Slice predicates	✅ Annotated
4	TypeContainer.ReflectionType / ToType()	Annotated as minimum chain required — follow-up can go deeper

<IsTrimmable> / <IsAotCompatible> are deliberately NOT set on the library project. Tier 2+ surfaces use runtime reflection into Mono.Cecil internals that cannot be made fully trim-safe without a major rewrite. Setting those flags would over-promise and suppress legitimate consumer warnings.

Changes

sources/NetArchTest/NetArchTestAotMessages.cs (new)

• Shared const string message used by all [RequiresUnreferencedCode] / [RequiresDynamicCode] attributes so the message is consistent and DRY.

sources/NetArchTest/Condition_Dependencies.cs, Predicate_Dependencies.cs, Slices/SliceCondition.cs, Functions/FunctionDelegates_Dependencies.cs

• [RequiresUnreferencedCode] + [RequiresDynamicCode] on every method in the dependency-search pipeline (Tier 2/3 surface).

sources/NetArchTest/Dependencies/TypeParser.cs

• Type-level [UnconditionalSuppressMessage] for IL2057/IL2077/IL2080 covering Mono.Cecil private-field reflection in the static .cctor.
• [RequiresUnreferencedCode] + [RequiresDynamicCode] on Parse() and ParseReflectionNameToRuntimeName().

sources/NetArchTest/Dependencies/DataStructures/NamespaceTree.cs

• Extracted the parseNames=true branch into a private ParseTokensRequiringReflection() annotated with Requires*. Add() gets [UnconditionalSuppressMessage] with justification: Tier 1 callers always pass parseNames=false so the reflection path is unreachable for them.

sources/NetArchTest/Extensions/Mono.Cecil/TypeDefinitionExtensions.cs

• [RequiresUnreferencedCode] + [RequiresDynamicCode] on ToType().

sources/NetArchTest/Assemblies/PublicUse/TypeContainer.cs

• Extracted Lazy<Type> initialiser lambda body into private ResolveReflectionType() annotated with Requires*. Constructor gets [UnconditionalSuppressMessage] (Tier 1 paths never read ReflectionType).

tests/NetArchTest.AotSmoke/ (new)

• NativeAOT publish smoke: exercises Types.FromPath + name/namespace/structural predicates only.
• PublishAot=true, TreatWarningsAsErrors=true, <NoWarn>IL2104</NoWarn> (Mono.Cecil 0.11.x is not trim-annotated upstream; IL2104 is its aggregate warning which we cannot fix from here — Tier 2 callers still receive proper annotations at their own call sites).
• Prints OK and exits 0 when the AOT image is correct.

tests/NetArchTest.AotSmoke.Fixture/ (new)

• Minimal netstandard2.0 DLL published alongside the smoke binary as a realistic input to Types.FromPath.

.github/workflows/net-workflow.yml

• New aot-smoke job on windows-latest: publishes the smoke project and runs the produced exe (asserts exit 0).

Local verification

dotnet build            → 0 errors (both TFMs)
dotnet test             → 353×2 passed, 2×2 skipped
dotnet publish (win-x64) → 0 IL warnings, 0 errors
./NetArchTest.AotSmoke.exe → "OK: NetArchTest AOT smoke passed." (exit 0)

Depends on

This PR was developed on top of the net10 TFM PR (#11). It can be rebased cleanly once that lands, or reviewed independently — the #if NET10_0_OR_GREATER guards mean netstandard2.0 builds are unaffected either way.