feat: 重构事件总线为可实例化架构并发布 1.3.0

- 新增 IShrinkEventBus、ShrinkEventBusBuilder 与 ShrinkEventBusInstance，支持独立 bus、异常策略、启动开关、类型校验和按 phase 派发
- 新增 SubscribeEvent 可释放订阅句柄与订阅快照接口，保留 EventBus 静态门面并委托到默认实例
- 重构监听列表为父子事件链共享锁与快照缓存，支持父事件监听子事件、跨父子数字优先级归并和防御性快照拷贝
- 优化 EventBase 元数据缓存、懒生成 EventId、派发快照挂接与对象池双重归还保护，移除旧 EventCache 热路径
- 恢复本地 ILPostProcessor 兜底并生成静态订阅注册表，避免共享 CodeGen 覆盖外程序集自动注册失效
- 改进事件查看器、Benchmark、README 与 CHANGELOG，并新增 Dispatch/Priority/Registration/Subscription 测试覆盖核心行为

BREAKING CHANGE: 移除 EventBase.GetListenerList()，int 数字优先级重载不再提供默认值，数字优先级 0 现在映射为 NORMAL。

Tests/EventBusRegistrationTests.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace ShrinkEventBus.Tests
+{
+    [TestFixture]
+    public sealed class EventBusRegistrationTests
+    {
+        private class ProbeEvent : EventBase
+        {
+        }
+
+        private sealed class PooledEvent : EventBase
+        {
+            public int Value { get; set; }
+
+            protected override void OnReset()
+            {
+                Value = 0;
+            }
+        }
+
+        private sealed class InstanceSubscriber
+        {
+            public int Hits;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnProbe(ProbeEvent evt)
+            {
+                Hits++;
+            }
+        }
+
+        private static class StaticSubscriber
+        {
+            public static int Hits;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private static void OnProbe(ProbeEvent evt)
+            {
+                Hits++;
+            }
+        }
+
+        private sealed class InvalidSignatureSubscriber
+        {
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnProbe(ProbeEvent evt, int extra)
+            {
+            }
+        }
+
+        [EventBusSubscriber]
+        private sealed class EmptySubscriber
+        {
+        }
+
+        private sealed class UnattributedSubscriber
+        {
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnProbe(ProbeEvent evt)
+            {
+            }
+        }
+
+        [Test]
+        public void Register_InstanceScan_RegistersAndUnregisters()
+        {
+            var bus = EventBus.CreateBus();
+            var subscriber = new InstanceSubscriber();
+
+            bus.Register(subscriber);
+            Assert.IsTrue(bus.IsInstanceRegistered(subscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, subscriber.Hits);
+
+            bus.Unregister(subscriber);
+            Assert.IsFalse(bus.IsInstanceRegistered(subscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, subscriber.Hits);
+        }
+
+        [Test]
+        public void Register_StaticTypeScan_RegistersAndUnregisters()
+        {
+            var bus = EventBus.CreateBus();
+            StaticSubscriber.Hits = 0;
+
+            bus.Register(typeof(StaticSubscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+
+            bus.Unregister(typeof(StaticSubscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+        }
+
+        [Test]
+        public void Register_MethodInfo_RegistersSingleHandler()
+        {
+            var bus = EventBus.CreateBus();
+            StaticSubscriber.Hits = 0;
+            var method = typeof(StaticSubscriber).GetMethod("OnProbe",
+                BindingFlags.Static | BindingFlags.NonPublic);
+            Assert.IsNotNull(method);
+
+            bus.Register(method);
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+
+            bus.Unregister(method);
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+        }
+
+        [Test]
+        public void Register_InvalidHandlerSignature_Throws()
+        {
+            var bus = EventBus.CreateBus();
+
+            Assert.Throws<InvalidOperationException>(() => bus.Register(new InvalidSignatureSubscriber()));
+        }
+
+        [Test]
+        public void AutoRegister_TypeWithoutSubscriberAttribute_Throws()
+        {
+            var bus = EventBus.CreateBus();
+
+            Assert.Throws<InvalidOperationException>(() => bus.AutoRegister(new UnattributedSubscriber()));
+        }
+
+        [Test]
+        public void AutoRegister_SubscriberWithoutHandlers_WarnsInsteadOfThrowing()
+        {
+            var bus = EventBus.CreateBus();
+
+            LogAssert.Expect(LogType.Warning, new Regex(@"has no \[EventSubscribe\] methods"));
+            Assert.DoesNotThrow(() => bus.AutoRegister(new EmptySubscriber()));
+        }
+
+        [Test]
+        public void GetEventSubscribers_ReturnsDefensiveCopy()
+        {
+            var bus = EventBus.CreateBus();
+            bus.RegisterEvent<ProbeEvent>(_ => { }, EventPriority.NORMAL);
+
+            var first = bus.GetEventSubscribers<ProbeEvent>();
+            Assert.AreEqual(1, first.Length);
+
+            first[0] = null;
+            var second = bus.GetEventSubscribers<ProbeEvent>();
+            Assert.IsNotNull(second[0]);
+        }
+
+        [Test]
+        public void UnregisterAllEventsForObject_RemovesScannedHandlers()
+        {
+            var bus = EventBus.CreateBus();
+            var subscriber = new InstanceSubscriber();
+            bus.Register(subscriber);
+
+            bus.UnregisterAllEventsForObject(subscriber);
+            bus.TriggerEvent(new ProbeEvent());
+
+            Assert.AreEqual(0, subscriber.Hits);
+        }
+
+        [Test]
+        public void EventPool_ReleaseResetsAndReusesInstance()
+        {
+            var evt = EventPool<PooledEvent>.Get();
+            evt.Value = 42;
+
+            EventPool<PooledEvent>.Release(evt);
+            var reused = EventPool<PooledEvent>.Get();
+
+            Assert.AreSame(evt, reused);
+            Assert.AreEqual(0, reused.Value);
+
+            EventPool<PooledEvent>.Release(reused);
+        }
+
+        [Test]
+        public void EventPool_DoubleRelease_DoesNotDuplicatePoolEntry()
+        {
+            var evt = EventPool<PooledEvent>.Get();
+
+            EventPool<PooledEvent>.Release(evt);
+            EventPool<PooledEvent>.Release(evt);
+
+            var first = EventPool<PooledEvent>.Get();
+            var second = EventPool<PooledEvent>.Get();
+
+            Assert.AreSame(evt, first);
+            Assert.AreNotSame(evt, second);
+
+            EventPool<PooledEvent>.Release(first);
+            EventPool<PooledEvent>.Release(second);
+        }
+
+        [Test]
+        public void EventPool_DisposeReturnsToPool()
+        {
+            PooledEvent captured;
+            using (var evt = EventPool<PooledEvent>.Get())
+            {
+                captured = evt;
+                evt.Value = 7;
+            }
+
+            var reused = EventPool<PooledEvent>.Get();
+            Assert.AreSame(captured, reused);
+            Assert.AreEqual(0, reused.Value);
+
+            EventPool<PooledEvent>.Release(reused);
+        }
+    }
+}