Refactor interactions, introduce template-method lifecycle management, work on save-load system (#51)

# Lifecycle Management & Save System Revamp

## Overview
Complete overhaul of game lifecycle management, interactable system, and save/load architecture. Introduces centralized `ManagedBehaviour` base class for consistent initialization ordering and lifecycle hooks across all systems.

## Core Architecture

### New Lifecycle System
- **`LifecycleManager`**: Centralized coordinator for all managed objects
- **`ManagedBehaviour`**: Base class replacing ad-hoc initialization patterns
  - `OnManagedAwake()`: Priority-based initialization (0-100, lower = earlier)
  - `OnSceneReady()`: Scene-specific setup after managers ready
  - Replaces `BootCompletionService` (deleted)
- **Priority groups**: Infrastructure (0-20) → Game Systems (30-50) → Data (60-80) → UI/Gameplay (90-100)
- **Editor support**: `EditorLifecycleBootstrap` ensures lifecycle works in editor mode

### Unified SaveID System
- Consistent format: `{ParentName}_{ComponentType}`
- Auto-registration via `AutoRegisterForSave = true`
- New `DebugSaveIds` editor tool for inspection

## Save/Load Improvements

### Enhanced State Management
- **Extended SaveLoadData**: Unlocked minigames, card collection states, combination items, slot occupancy
- **Async loading**: `ApplyCardCollectionState()` waits for card definitions before restoring
- **New `SaveablePlayableDirector`**: Timeline sequences save/restore playback state
- **Fixed race conditions**: Proper initialization ordering prevents data corruption

## Interactable & Pickup System

- Migrated to `OnManagedAwake()` for consistent initialization
- Template method pattern for state restoration (`RestoreInteractionState()`)
- Fixed combination item save/load bugs (items in slots vs. follower hand)
- Dynamic spawning support for combined items on load
- **Breaking**: `Interactable.Awake()` now sealed, use `OnManagedAwake()` instead

##  UI System Changes

- **AlbumViewPage** and **BoosterNotificationDot**: Migrated to `ManagedBehaviour`
- **Fixed menu persistence bug**: Menus no longer reappear after scene transitions
- **Pause Menu**: Now reacts to all scene loads (not just first scene)
- **Orientation Enforcer**: Enforces per-scene via `SceneManagementService`
- **Loading Screen**: Integrated with new lifecycle

## ⚠️ Breaking Changes

1. **`BootCompletionService` removed** → Use `ManagedBehaviour.OnManagedAwake()` with priority
2. **`Interactable.Awake()` sealed** → Override `OnManagedAwake()` instead
3. **SaveID format changed** → Now `{ParentName}_{ComponentType}` consistently
4. **MonoBehaviours needing init ordering** → Must inherit from `ManagedBehaviour`

Co-authored-by: Michal Pikulski <michal.a.pikulski@gmail.com>
Co-authored-by: Michal Pikulski <michal@foolhardyhorizons.com>
Reviewed-on: #51

Assets/Scripts/Levels/MinigameSwitch.cs

@@ -4,19 +4,16 @@ using Core;
 using Input;
 using Interactions;
 using System.Threading.Tasks;
-using Bootstrap;
 using PuzzleS;
 using UnityEngine;
-using Core.SaveLoad;
 
-// Added for IInteractionSettings
 
 namespace Levels
 {
     /// <summary>
     /// Saveable data for MinigameSwitch state
     /// </summary>
-    [System.Serializable]
+    [Serializable]
     public class MinigameSwitchSaveData
     {
         public bool isUnlocked;
@@ -50,9 +47,7 @@ namespace Levels
         /// </summary>
         protected override void Awake()
         {
-            base.Awake(); // Register with save system
-
-            BootCompletionService.RegisterInitAction(InitializePostBoot);
+            base.Awake();
 
             switchActive = true;
             if (iconRenderer == null)
@@ -68,10 +63,10 @@ namespace Levels
             interactionSettings = GameManager.GetSettingsObject<IInteractionSettings>();
             ApplySwitchData();
         }
-
-        protected override void Start()
+        
+        protected override void OnManagedAwake()
         {
-            base.Start(); // Register with save system
+            base.OnManagedAwake();
             
             // If startUnlocked is true, always start active
             if (startUnlocked)
@@ -80,16 +75,25 @@ namespace Levels
                 return;
             }
             
-            // Otherwise, if not restoring from save, start inactive
+            if (PuzzleManager.Instance != null)
+            {
+                PuzzleManager.Instance.OnAllPuzzlesComplete += HandleAllPuzzlesComplete;
+            }
+            
             if (!IsRestoringFromSave && !isUnlocked)
             {
                 gameObject.SetActive(false);
             }
         }
-
+        
         protected override void OnDestroy()
         {
-            base.OnDestroy(); // Unregister from save system
+            base.OnDestroy();
+            
+            if (PuzzleManager.Instance != null)
+            {
+                PuzzleManager.Instance.OnAllPuzzlesComplete -= HandleAllPuzzlesComplete;
+            }
         }
 
         private void HandleAllPuzzlesComplete(PuzzleS.PuzzleLevelDataSO _)
@@ -98,7 +102,13 @@ namespace Levels
             isUnlocked = true;
             gameObject.SetActive(true);
             
-            // Save will happen automatically on next save cycle via ISaveParticipant
+            // Add to global unlocked minigames list
+            if (switchData != null && !string.IsNullOrEmpty(switchData.targetLevelSceneName))
+            {
+                Core.SaveLoad.SaveLoadManager.Instance?.UnlockMinigame(switchData.targetLevelSceneName);
+            }
+            
+            // Save will happen automatically on next save cycle via SaveableInteractable
         }
 
 #if UNITY_EDITOR
@@ -128,34 +138,56 @@ namespace Levels
         }
 
         /// <summary>
-        /// Handles the start of an interaction (shows confirmation menu and switches the level if confirmed).
+        /// High-level validation: Only allow interaction if unlocked.
         /// </summary>
-        protected override void OnCharacterArrived()
+        protected override bool CanBeClicked()
         {
-            if (switchData == null || string.IsNullOrEmpty(switchData.targetLevelSceneName) || !switchActive)
-                return;
+            return base.CanBeClicked() && isUnlocked;
+        }
+
+        /// <summary>
+        /// Setup: Prevent re-entry while interaction is in progress.
+        /// </summary>
+        protected override void OnInteractionStarted()
+        {
+            switchActive = false;
+        }
+
+        /// <summary>
+        /// Main interaction logic: Spawn menu and switch input mode.
+        /// </summary>
+        protected override bool DoInteraction()
+        {
+            if (switchData == null || string.IsNullOrEmpty(switchData.targetLevelSceneName))
+            {
+                Debug.LogWarning("MinigameSwitch has no valid switchData!");
+                return false;
+            }
 
             var menuPrefab = interactionSettings?.MinigameSwitchMenuPrefab;
             if (menuPrefab == null)
             {
                 Debug.LogError("MinigameSwitchMenu prefab not assigned in InteractionSettings!");
-                return;
+                return false;
             }
-            // Spawn the menu overlay (assume Canvas parent is handled in prefab setup)
+            
+            // Spawn the menu overlay
             var menuGo = Instantiate(menuPrefab);
             var menu = menuGo.GetComponent<MinigameSwitchMenu>();
             if (menu == null)
             {
                 Debug.LogError("MinigameSwitchMenu component missing on prefab!");
                 Destroy(menuGo);
-                return;
+                return false;
             }
+            
             // Setup menu with data and callbacks
             menu.Setup(switchData, OnLevelSelectedWrapper, OnMenuCancel);
-            switchActive = false; // Prevent re-triggering until menu is closed
-        
+            
             // Switch input mode to UI only
             InputManager.Instance.SetInputMode(InputMode.UI);
+            
+            return true; // Menu spawned successfully
         }
 
         private void OnLevelSelectedWrapper()
@@ -175,10 +207,6 @@ namespace Levels
             InputManager.Instance.SetInputMode(InputMode.GameAndUI);
         }
 
-        private void InitializePostBoot()
-        {
-            PuzzleManager.Instance.OnAllPuzzlesComplete += HandleAllPuzzlesComplete;
-        }
 
         #region Save/Load Implementation
 
@@ -209,6 +237,12 @@ namespace Levels
 
             isUnlocked = data.isUnlocked;
             
+            // Sync with global unlocked minigames list
+            if (isUnlocked && switchData != null && !string.IsNullOrEmpty(switchData.targetLevelSceneName))
+            {
+                Core.SaveLoad.SaveLoadManager.Instance?.UnlockMinigame(switchData.targetLevelSceneName);
+            }
+            
             // Show/hide based on unlock state
             gameObject.SetActive(isUnlocked);
         }