feat(battle-engine-port): M2 step 1 — SingleBattleMgr constructs headless

First green of the M2 go/no-go probe: `new SingleBattleMgr(StandardBattleMgr-
ContentsCreator)` now builds the two-player pair fully headless against the shim,
no Unity runtime. Verdict: headless construction is feasible; every blocker was a
mechanical no-op shim fill or data seam, not a Unity/logic wall.

Shim fills (authored):
- GameMgr: lazy non-null DataMgr/PrefabMgr/InputMgr/SoundMgr/BattleControl.
- GameObject: lazy cached component model so GetComponent<T>/AddComponent<T> return
  non-null no-op instances for Component-derived T (F1: unguarded view touches).
- Resources.Load(string): cached non-null GameObject so the prefab->Instantiate->
  GetComponent chain (UnityEventAgent) yields a real object.
- ClassBattleCardViewBase: re-attach dropped IClassBattleCardView (no-op members);
  ClassBattleCardBase.Setup casts the created view to it.

Engine copy (DP1/DP3 mis-cut fix):
- CardIconControl.cs copied verbatim (manifested) + generated null-stub deleted.
  SplitAndCompleteIconStr is pure string logic on the resolution path that M1 had
  wrongly stubbed as "View" -> null deref in SkillCreator.CreateBuildInfo.

Test harness (SVSim.BattleEngine.Tests, authored fixture):
- HeadlessContentsCreator/HeadlessPhaseCreator: deterministic replica of the solo
  practice init (StandardBattleMgrContentsCreator + SingleBattlePhaseCreator) with
  no-op recovery/replay managers.
- HeadlessCardMaster: reflects the loader cards.json dump into CardMaster.
- HeadlessMasterData: minimal Data.Master (class-character list, empty collections)
  + Data.Load + player/enemy chara ids.
- ConstructionProbeTests.SingleBattleMgr_constructs_headless — GREEN.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

SVSim.BattleEngine/Shim/UnityEngine/UnityRuntime.cs

@@ -50,8 +50,19 @@ namespace UnityEngine
     {
         public static T Load<T>(string path) where T : Object => null;
         public static T Load<T>(string path, Type t) where T : Object => null;
-        public static Object Load(string path) => null;
-        public static Object Load(string path, Type t) => null;
+        // Headless: the non-generic Load is used by the copied PrefabMgr to back a prefab
+        // dictionary that the resolution-path ctor then Instantiate()s + GetComponent()s
+        // (e.g. Prefab/Game/UnityEventAgent). Return a cached no-op GameObject per path so that
+        // chain yields a non-null object. Typed asset loads go through the generic Load<T> (null).
+        private static readonly System.Collections.Generic.Dictionary<string, GameObject> _loaded
+            = new System.Collections.Generic.Dictionary<string, GameObject>();
+        public static Object Load(string path)
+        {
+            if (string.IsNullOrEmpty(path)) return null;
+            if (!_loaded.TryGetValue(path, out var go)) { go = new GameObject(path); _loaded[path] = go; }
+            return go;
+        }
+        public static Object Load(string path, Type t) => Load(path);
         public static T[] LoadAll<T>(string path) where T : Object => new T[0];
         public static Object[] LoadAll(string path) => new Object[0];
         public static ResourceRequest LoadAsync<T>(string path) where T : Object => null;

SVSim.BattleEngine/Shim/UnityEngine/UnityShim.cs

@@ -185,8 +185,25 @@ namespace UnityEngine
         public int layer { get; set; }
         public string tag { get; set; }
         public void SetActive(bool value) { }
-        public T GetComponent<T>() => default;
-        public Component GetComponent(Type t) => null;
+
+        // Headless component model: the resolution-path ctor (and copied views) acquire components
+        // off prefab GameObjects and use them unguarded (F1). Lazily create + cache a no-op instance
+        // per concrete Component-derived type so those touches resolve harmlessly instead of NRE.
+        // Non-Component T or abstract/uninstantiable T still returns default (null).
+        private System.Collections.Generic.Dictionary<Type, object> _components;
+        private object GetOrAddComponent(Type t)
+        {
+            if (t == null || t.IsAbstract || !typeof(Component).IsAssignableFrom(t)) return null;
+            _components ??= new System.Collections.Generic.Dictionary<Type, object>();
+            if (_components.TryGetValue(t, out var c)) return c;
+            object inst;
+            try { inst = Activator.CreateInstance(t); }
+            catch { return null; }
+            _components[t] = inst;
+            return inst;
+        }
+        public T GetComponent<T>() => (T)(GetOrAddComponent(typeof(T)) ?? default(T));
+        public Component GetComponent(Type t) => (Component)GetOrAddComponent(t);
         public Component GetComponent(string t) => null;
         public T GetComponentInChildren<T>() => default;
         public T GetComponentInChildren<T>(bool includeInactive) => default;
@@ -196,8 +213,8 @@ namespace UnityEngine
         public T GetComponentInParent<T>(bool includeInactive) => default;
         public T[] GetComponents<T>() => new T[0];
         public Component[] GetComponents(Type t) => new Component[0];
-        public T AddComponent<T>() where T : Component => default;
-        public Component AddComponent(Type t) => null;
+        public T AddComponent<T>() where T : Component => (T)(GetOrAddComponent(typeof(T)) ?? default(T));
+        public Component AddComponent(Type t) => (Component)GetOrAddComponent(t);
         public void SendMessage(string method) { }
         public void SendMessage(string method, object value) { }
         public void SendMessage(string method, object value, SendMessageOptions options) { }