Reload-proof Singleton

There is no way without black magic, but here is that black magic ^_^:

using UnityEngine;
using System.IO;

#if UNITY_EDITOR
using UnityEditor;
#endif

#if UNITY_EDITOR
public static class ScriptableObjectUtility
{
    /// <summary>
    /// This makes it easy to create, name and place unique new ScriptableObject asset files.
    /// </summary>
    public static T CreateAsset<T>(string path, string name) where T : ScriptableObject
    {
        T asset = ScriptableObject.CreateInstance<T>();

        if (path == string.Empty)
        {
            path = "Assets";
        }
        else if (Path.GetExtension(path) != string.Empty)
        {
            path = path.Replace(Path.GetFileName(AssetDatabase.GetAssetPath(Selection.activeObject)), string.Empty);
        }

        string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(Path.Combine(path, name + ".asset"));

        AssetDatabase.CreateAsset(asset, assetPathAndName);

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
        EditorUtility.FocusProjectWindow();
        Selection.activeObject = asset;

        return asset;
    }
}
#endif

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

// Reload-proof Singleton
[CreateAssetMenu(fileName = GameState.DEFAULT_GAME_STATE_NAME, menuName = "Game State", order = 202)]
public class GameState : ScriptableObject
{
    private const string DEFAULT_GAME_STATE_NAME = "Game State";

    public static GameState instance;
    public static GameState Instance
    {
        get { return instance ?? 
                (instance = Resources.Load<GameState>(GameState.DEFAULT_GAME_STATE_NAME)) ?? 
                (instance = ScriptableObjectUtility.CreateAsset<GameState>(Path.Combine("Assets", "Resources"), GameState.DEFAULT_GAME_STATE_NAME)); }
    }

    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
    private static void CreateGameStateManager()
    {
        new GameObject("[Game State Manager]", typeof(GameStateManager));
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameStateManager : MonoBehaviour
{
    private void Awake()
    {
        if (GameState.Instance == null) // Null check is important, it's also a way to initialize and find GameState on Awake to prevent spike during gameplay.
        {
#if UNITY_EDITOR
            Debug.LogError("Game State instance could neither be found nor created.");
#endif
        }
    }
}

Just Thoughts

The basic idea behind this is that ScriptableObjects preserve data between scenes (if I am not mistaken). So having only 1 instance of GameStateshould keep things in check. It's automaticallylazyloaded fromResourceswhen addressed.[Game State Manager]is created before scene load, so it should be first to initialize (but I am not sure, I didn't test it) and is created automatically for every scene and deleted when scene is unloaded. If you load scenes inAdditive` way then you would have to make some manipulations to keep only 1 instance of it for both scenes, I didn't have time to test additive scene loading with it, but it's great approach, I will probably use it in a few months and update my answer to share more info.