AOT: core module-serializer table (#8626, part 1)

[Aaronontheweb]

First PR of the #8626 stack. It adds the core half of the module serializer table. No module ships a table yet; the Remote, Cluster family and Persistence PRs each add one.

What changes

• ModuleSerializers (internal, abstract): a module lists its serializers as ModuleSerializer(Type, Func<ExtendedActorSystem, Config, Serializer>) and its bound types as IReadOnlyList<Type>.
• ModuleSerializerTable (internal): maps an assembly simple name to a lambda that calls Load("<literal type name>"). Load takes a [DynamicallyAccessedMembers(PublicParameterlessConstructor)] string, the same pattern as CreateProvider in AOT: resolve built-in actor ref providers from constant type names so the trimmer preserves them #8599. Each module gets its own lambda and literal, so the trimmer keeps each table type. The map is empty in this PR.
  • Lazy: a module loads only when a row misses core's built-in tables and the row's assembly half names that module. Rows that hit the built-in tables never probe.
  • Cached per assembly (case-insensitive) in a ConcurrentDictionary, as a lookup keyed by stripped full name that is built once when the module loads, so each row is a dictionary hit.
  • Version skew (TypeLoadException, MissingMemberException, FileNotFoundException or FileLoadException, unwrapped through any depth of TargetInvocationException / TypeInitializationException) makes the module count as absent. Both lists are read inside that guard, so a missing member in the table's constructor, static initializer or list getters is covered.
• Serialization constructor, per row: built-in table, then module table, then reflection (switch on) or SerializationSetup/NotBuiltIn (switch off). With the switch on, the module arm swaps reflection for direct construction that gives the same Type and serializer class, so JIT behavior does not change.
• Matching follows what Type.GetType accepts when called from Akka.dll: full type name plus assembly simple name, case-insensitive. A bare name matches only Akka.dll and framework types (so "Akka.Actor.Identify" works with the switch off as it does with it on, per AOT M1-G: one matching rule for every built-in type name #8613); a bare name for a type in another module is rejected, as reflection rejects it. A framework type (System.String) also matches any of the existing FrameworkAssemblyNames.
• Binding rows whose type lives outside the module (Remote.conf's "System.String", "Akka.Actor.Identify, Akka", "Google.Protobuf.IMessage, Google.Protobuf") resolve against the modules this config's serializer rows loaded. Two modules that list the same name list the same Type, so the order does not matter.
• One small widening: a binding row whose assembly half names a known module resolves through that module's table even when the module's serializer rows are absent from the config.
• Internal ctor Serialization(ExtendedActorSystem, ModuleSerializerTable) for tests. The public ctor uses ModuleSerializerTable.Default.

No public API change and no ledger entry.

Tests

ModuleSerializersSpec (in DynamicTypeLoadingCollection) uses a fake module keyed as Akka.Tests:

• switch off: the module's serializer row and its binding rows (module type, System.String, Akka.Actor.Identify, Akka) resolve, with one probe;
• an application.conf override of a module type (and of System.String) to bytes wins;
• a non-module serializer row and a non-module binding row still throw NotBuiltIn;
• strict matching: the module's type under another assembly, or as a bare name, throws;
• a bare Akka.dll name ("Akka.Actor.PoisonPill") that a loaded module binds resolves, matching reflection;
• with no module serializer row, "System.String" = bytes still throws NotBuiltIn with the switch off, and nothing is probed;
• a SerializationSetup-covered alias is still skipped;
• switch on: same serializer class and same constructor choice (with and without a settings block) as reflection;
• version skew: a table whose constructor throws MissingMethodException, one whose static initializer does, and a table type that does not exist all count as absent: reflection works with the switch on, and the switch-off error is the ordinary NotBuiltIn;
• a default config never probes, with the switch on or off.

Validation

• dotnet build -c Release -warnaserror for Akka and Akka.Tests
• Akka.Tests: Serialization + Util + BuiltIn filters, and the full suite
• Akka.API.Tests: no change
• AOT canary: unrooted publish and run print [canary] OK with the same 4 IL warnings; the rooted publish passes CheckAotWarnings with no new baseline entries

[Aaronontheweb]

LGTM - this just adds the infrastructure for supporting AOT-compatible built-in serializer loading. The actual work on a per-module basis will happen downstream.

[Aaronontheweb]

this is getting populated in a follow-up PR