Optimize generated activation factories for authored components

[Sergio0694]

Summary

Optimize the *ServerActivationFactory classes generated for authored Windows Runtime components: the static constructor that forces the authored type's class constructor to run before activation is now emitted only when the type actually needs it (i.e. when it, or an authored base type, registers XAML dependency properties). For all other authored types it is pure overhead and is now omitted.

Motivation

Every generated activation factory used to emit a static constructor calling RuntimeHelpers.RunClassConstructor(typeof(T).TypeHandle). That is only required when the authored type registers XAML dependency properties (declared as static DependencyProperty fields), so they are registered before the type is first activated. For every other type the static constructor is unnecessary work at activation time, so making it pay-for-play removes that overhead.

Whether a type registers dependency properties cannot be answered from the .winmd metadata (it does not carry static fields), so the change also threads the component's compiled implementation assemblies into the projection writer and adds the infrastructure to answer that question on demand while emitting each factory. Along the way it consolidates a small shared helper (SignatureComparer.IgnoreVersion) into the shared generator core so both the projection writer and the interop generator use a single copy.

Changes

The PR is organised into focused commits:

• Plumb the managed implementation assemblies into the projection writer — ProjectionWriterOptions.ComponentImplementationAssemblyPaths (carried through Settings) exposes the authored component's compiled .dll(s) to the writer, and the projection generator host collects, in component mode, the reference assemblies marked [WindowsRuntimeComponentAssembly].
• Skip the activation factory static constructor when not needed — ComponentFactory.WriteFactoryClass emits the static constructor only when required, via a callback so the factory body stays a single interpolated template; adds DependencyProperty and the Microsoft.UI.Xaml / Windows.UI.Xaml namespaces to the well-known name references.
• Move SignatureComparer.IgnoreVersion to the shared generator core — promotes the version-agnostic comparer to WinRT.Generator.Core and migrates both the projection writer and the interop generator to consume the single shared copy, removing the interop generator's duplicate.
• Make the dependency-property analysis lazy — ComponentImplementationMetadata is a thin resolver that indexes the managed assemblies' types by name, and a new ComponentStaticConstructorAnalyzer computes the requirement on demand, walking base types lazily and memoizing per visited type so shared hierarchies are traversed once.
• Compute the requirement on the fly via the emit context — ProjectionEmitContext carries the shared analyzer, so WriteFactoryClass derives the answer from the type and context instead of taking a pre-computed flag; the analyzer's cache is concurrent since it is queried from the parallel emission work items.

Backward compatible: when the implementation assemblies are not available (e.g. reference-projection generation), the analysis conservatively keeps the static constructor, matching the previous always-emit behavior.