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/UI/PauseMenu.cs

@@ -1,8 +1,8 @@
 using System;
 using Core;
+using Core.SaveLoad;
 using UnityEngine;
 using UnityEngine.SceneManagement;
-using Bootstrap;
 using UI.Core;
 using Pixelplacement;
 
@@ -22,9 +22,14 @@ namespace UI
         [SerializeField] private GameObject pauseButton;
         [SerializeField] private CanvasGroup canvasGroup;
 
+        // After UIPageController (50)
+        public override int ManagedAwakePriority => 55;
         
-        private void Awake()
+        private new void Awake()
         {
+            base.Awake(); // CRITICAL: Register with LifecycleManager!
+            
+            // Set instance immediately so it's available before OnManagedAwake() is called
             _instance = this;
             
             // Ensure we have a CanvasGroup for transitions
@@ -32,19 +37,22 @@ namespace UI
                 canvasGroup = GetComponent<CanvasGroup>();
             if (canvasGroup == null)
                 canvasGroup = gameObject.AddComponent<CanvasGroup>();
+            
+            // Set initial state
             canvasGroup.alpha = 0f;
             canvasGroup.interactable = false;
             canvasGroup.blocksRaycasts = false;
             gameObject.SetActive(false);
-            
-            // Register for post-boot initialization
-            BootCompletionService.RegisterInitAction(InitializePostBoot);
         }
-
-        private void InitializePostBoot()
+        
+        protected override void OnManagedAwake()
         {
-            // Subscribe to scene loaded events
-            SceneManagerService.Instance.SceneLoadCompleted += SetPauseMenuByLevel;
+            // Subscribe to scene-dependent events - must be in OnManagedAwake, not OnSceneReady
+            // because PauseMenu is in DontDestroyOnLoad and OnSceneReady only fires once
+            if (SceneManagerService.Instance != null)
+            {
+                SceneManagerService.Instance.SceneLoadCompleted += SetPauseMenuByLevel;
+            }
             
             // Also react to global UI hide/show events from the page controller
             if (UIPageController.Instance != null)
@@ -53,16 +61,21 @@ namespace UI
                 UIPageController.Instance.OnAllUIShown += HandleAllUIShown;
             }
 
-            // SceneManagerService subscription moved to InitializePostBoot
-            
             // Set initial state based on current scene
             SetPauseMenuByLevel(SceneManager.GetActiveScene().name);
-    
+
             Logging.Debug("[PauseMenu] Subscribed to SceneManagerService events");
         }
 
-        private void OnDestroy()
+        protected override void OnSceneReady()
         {
+            // This only fires once for DontDestroyOnLoad objects, so we handle scene loads in OnManagedAwake
+        }
+
+        protected override void OnDestroy()
+        {
+            base.OnDestroy();
+            
             // Unsubscribe when destroyed
             if (SceneManagerService.Instance != null)
             {
@@ -81,17 +94,30 @@ namespace UI
         /// <param name="levelName">The name of the level/scene</param>
         public void SetPauseMenuByLevel(string levelName)
         {
-            HidePauseMenu();
-            // TODO: Implement level-based pause menu visibility logic if needed
-            /*if (string.IsNullOrEmpty(levelName))
-                return;
-                
-            bool isStartingLevel = levelName.ToLower().Contains("startingscene");
+            // When a new scene loads, ensure pause menu is removed from UIPageController stack
+            // and properly hidden, regardless of pause state
+            if (UIPageController.Instance != null && UIPageController.Instance.CurrentPage == this)
+            {
+                UIPageController.Instance.PopPage();
+            }
             
-            if(isStartingLevel)
-                HidePauseMenu(false); // Ensure menu is hidden when switching to a game level
+            // Ensure pause state is cleared
+            if (GameManager.Instance != null && GameManager.Instance.IsPaused)
+            {
+                EndPauseSideEffects();
+            }
             
-            Logging.Debug($"[PauseMenu] Setting pause menu active: {!isStartingLevel} for scene: {levelName}");*/
+            // Hide the menu UI
+            if (pauseMenuPanel != null) pauseMenuPanel.SetActive(false);
+            if (canvasGroup != null)
+            {
+                canvasGroup.alpha = 0f;
+                canvasGroup.interactable = false;
+                canvasGroup.blocksRaycasts = false;
+            }
+            gameObject.SetActive(false);
+            
+            Logging.Debug($"[PauseMenu] Cleaned up pause menu state for scene: {levelName}");
         }
 
         /// <summary>
@@ -238,6 +264,18 @@ namespace UI
         /// </summary>
         public async void ExitToAppleHills()
         {
+            // Pop from UIPageController stack before switching scenes
+            if (UIPageController.Instance != null && UIPageController.Instance.CurrentPage == this)
+            {
+                UIPageController.Instance.PopPage();
+            }
+            
+            // Ensure pause state is cleared
+            if (GameManager.Instance != null && GameManager.Instance.IsPaused)
+            {
+                EndPauseSideEffects();
+            }
+            
             // Replace with the actual scene name as set in Build Settings
             var progress = new Progress<float>(p => Logging.Debug($"Loading progress: {p * 100:F0}%"));
             await SceneManagerService.Instance.SwitchSceneAsync("AppleHillsOverworld", progress);
@@ -257,8 +295,20 @@ namespace UI
 
         public async void ReloadLevel()
         {
+            // Clear all save data for the current gameplay level before reloading
+            if (SaveLoadManager.Instance != null && SceneManagerService.Instance != null)
+            {
+                string currentLevel = SceneManagerService.Instance.CurrentGameplayScene;
+                if (!string.IsNullOrEmpty(currentLevel))
+                {
+                    SaveLoadManager.Instance.ClearLevelData(currentLevel);
+                    Logging.Debug($"[PauseMenu] Cleared save data for current level: {currentLevel}");
+                }
+            }
+            
+            // Now reload the current scene with fresh state - skipSave=true prevents re-saving cleared data
             var progress = new Progress<float>(p => Logging.Debug($"Loading progress: {p * 100:F0}%"));
-            await SceneManagerService.Instance.ReloadCurrentScene(progress);
+            await SceneManagerService.Instance.ReloadCurrentScene(progress, autoHideLoadingScreen: true, skipSave: true);
         }
         
         /// <summary>