feat: add interface-based observation plugin system with affinity-based selection

Replace 7 static observation generator classes with an interface-based plugin
system where plugins compete by affinity to generate platform-specific,
reflection-free observation code. Affinity values now match ReactiveUI's exact
runtime values (KVO=15, ReactiveObject=10, WinForms=8, WinUI=6, INPC=5,
Android=5, WPF=4).

Each plugin generates code that mirrors the corresponding ReactiveUI runtime
implementation but without reflection:

- WPF: EventObservable with DependencyPropertyDescriptor.AddValueChanged
- WinUI: inline __WinUIDPObservable with RegisterPropertyChangedCallback
- WinForms: EventObservable with direct {Property}Changed event subscription
- KVO: inline __KVOObservable with NSObject.AddObserver and compile-time
  resolved key paths (lowercase first char, boolean "is" prefix)
- INPC/ReactiveObject: PropertyObservable/PropertyChangingObservable
- Android: ReturnObservable fallback (no INPC on Android View)

Pipeline A simplified from 7 separate filter calls + Consolidate() to a single
plugin-based step via ObservationPluginRegistry.GetBestPlugin().

New runtime type EventObservable<T> provides platform-agnostic event-based
observation using pure BCL types (Action<EventHandler> add/remove pattern).

100% line and branch coverage maintained across the full solution (7236 tests).

Author: glennawatson

src/ReactiveUI.Binding.SourceGenerators/BindingGenerator.cs

@@ -6,9 +6,10 @@
 using Microsoft.CodeAnalysis.CSharp;
 
 using ReactiveUI.Binding.SourceGenerators.Generators;
-using ReactiveUI.Binding.SourceGenerators.Generators.Observation;
 using ReactiveUI.Binding.SourceGenerators.Helpers;
 using ReactiveUI.Binding.SourceGenerators.Invocations;
+using ReactiveUI.Binding.SourceGenerators.Models;
+using ReactiveUI.Binding.SourceGenerators.Plugins;
 
 namespace ReactiveUI.Binding.SourceGenerators;
 
@@ -60,18 +61,31 @@ internal static partial class __ReactiveUIGeneratedBindings
             .Where(static x => x is not null)
             .Select(static (x, _) => x!);
 
-        // Per-kind fallback generators FILTER from allClasses (no independent RegisterSourceOutput)
-        var reactiveObjTypes = ReactiveObjectBindingGenerator.Filter(allClasses);
-        var inpcTypes = INPCBindingGenerator.Filter(allClasses);
-        var wpfTypes = WpfBindingGenerator.Filter(allClasses);
-        var winuiTypes = WinUIBindingGenerator.Filter(allClasses);
-        var kvoTypes = KVOBindingGenerator.Filter(allClasses);
-        var winformsTypes = WinFormsBindingGenerator.Filter(allClasses);
-        var androidTypes = AndroidBindingGenerator.Filter(allClasses);
+        // Single plugin-based step replaces 7 separate filter calls.
+        // Each type is matched against the plugin registry; the highest-affinity
+        // matching plugin determines the observation kind and capabilities.
+        var allObservableTypes = allClasses
+            .Select(static (classInfo, _) =>
+            {
+                var plugin = ObservationPluginRegistry.GetBestPlugin(classInfo);
+                if (plugin is null)
+                {
+                    return null;
+                }
+
+                return new ObservableTypeInfo(
+                    classInfo.FullyQualifiedName,
+                    classInfo.MetadataName,
+                    plugin.ObservationKind,
+                    plugin.Affinity,
+                    plugin.SupportsBeforeChanged,
+                    classInfo.Properties);
+            })
+            .Where(static x => x is not null)
+            .Select(static (x, _) => x!);
 
-        // Consolidate all per-kind results → single RegisterSourceOutput
-        var consolidated = RegistrationGenerator.Consolidate(
-            reactiveObjTypes, inpcTypes, wpfTypes, winuiTypes, kvoTypes, winformsTypes, androidTypes);
+        // Consolidate all observable types → single RegisterSourceOutput
+        var consolidated = allObservableTypes.Collect();
 
         context.RegisterSourceOutput(
             consolidated,