Перечисление дочерних классов для выбора

Я знаю, что это выходит за рамки вашего вопроса, но вот.

Мы надеемся, что комментарии в коде должны объяснять каждый шаг.

[CreateAssetMenu]
public class Whole : ScriptableObject
{
    public List<PartBase> parts = new();

#if UNITY_EDITOR

    // A custom Inspector for this type to extend it with an additional button
    [CustomEditor(typeof(Whole))]
    private class WholeEditor : Editor
    {
        // serialized property for the "parts"
        private SerializedProperty m_PartsProperty;

        // tiny hack to simulate a dropdown (see below)
        private Rect _rect;

        private void OnEnable()
        {
            // link up serialized property
            m_PartsProperty = serializedObject.FindProperty(nameof(parts));
        }

        public override void OnInspectorGUI()
        {
            // draw the default inspector
            base.OnInspectorGUI();

            EditorGUILayot.Space();
            
            var buttonClicked = GUILayout.Button("Add Part");
            if (Event.current.type == EventType.Repaint)
            {
                // little hack to get the button rect in order to place
                // our popup window here to kinda simulate a dropdown
                _rect = GUIUtility.GUIToScreenRect(GUILayoutUtility.GetLastRect());
            }

            if (buttonClicked)
            {
                // Get the FOLDER where the current main asset is placed
                // we will place created part assets here as well
                var mainAssetPath = AssetDatabase.GetAssetPath(target);
                var parts = mainAssetPath.Split('/').ToList();
                parts.RemoveAt(parts.Count - 1);
                mainAssetPath = string.Join('/', parts);

                // shift the target position lower to start the window right under the "Add Part" button
                _rect.y += _rect.height;

                WholeEditorAddPopup.OpenPopup(_rect, m_PartsProperty, mainAssetPath);
            }
        }

        private class WholeEditorAddPopup : EditorWindow
        {
            // The property where to finally add the created part
            private SerializedProperty m_ListProperty;

            // available Types and their according display names
            private Type[] m_AvailableTypes;
            private GUIContent[] m_DisplayOptions;

            // just the label for the dropdown
            private readonly GUIContent m_Label = new("Part to add");

            // Folder where to create assets
            private string m_MainAssetPath;

            // currently selected type index
            private int m_Selected = -1;

            public static void OpenPopup(Rect buttonRect, SerializedProperty listProperty, string mainAssetPath)
            {
                // create a new instance of this window
                var window = GetWindow<WholeEditorAddPopup>(true, "Add Part");
                // assign the fields
                window.m_ListProperty = listProperty;
                window.m_MainAssetPath = mainAssetPath;

                // get all assemblies
                window.m_AvailableTypes = AppDomain.CurrentDomain.GetAssemblies()
                    // get all Types
                    .SelectMany(assembly => assembly.GetTypes())
                    // Filter to only have non-abstract child classes of "PartBase"
                    .Where(type => type.IsSubclassOf(typeof(PartBase)) && !type.IsAbstract) 
                    // order by "FullName" (=> including namespaces)
                    .OrderBy(type => type.FullName)
                    .ToArray();

                // For the display names replace all "." by "/"
                // => Unity treats those as nested folders in the popup (see demo below)
                window.m_DisplayOptions = window.m_AvailableTypes.Select(type => new GUIContent(type.FullName.Replace('.', '/'))).ToArray();

                // show as Dropdown -> clicking outside automatically closes window
                window.ShowAsDropDown(buttonRect, new Vector2(buttonRect.width, EditorGUIUtility.singleLineHeight * 4));
                // [optional] set position again since "ShowAsDropDown" might have hanged it 
                window.position = new Rect(buttonRect.x, buttonRect.y, buttonRect.width, EditorGUIUtility.singleLineHeight * 4);
            }

            private void OnGUI()
            {
                // Draw a dropdown button containing all the available types
                // grouped by namespaces and ordered alphabetically
                m_Selected = EditorGUILayout.Popup(m_Label, m_Selected, m_DisplayOptions);

                // only enable the "Add" button if valid index selected
                var blockAdd = m_Selected < 0;

                EditorGUILayout.Space();

                using (new EditorGUI.DisabledScope(blockAdd))
                {
                    if (GUILayout.Button("Add"))
                    {
                        // get selected type by selected index
                        var selectedType = m_AvailableTypes[m_Selected];

                        // create runtime ScriptableObject instance by selected type
                        var part = CreateInstance(selectedType);
                        // Set its initial name
                        part.name = $"new {selectedType.Name}";

                        // Get a unique path for this asset
                        // => if already an asset with same name Unity adds an auto-incremented index 
                        var path = AssetDatabase.GenerateUniqueAssetPath($"{m_MainAssetPath}/{part.name}.asset");

                        // Create the asset, save and refresh
                        AssetDatabase.CreateAsset(part, path);
                        AssetDatabase.SaveAssets();
                        AssetDatabase.Refresh();

                        // not sure anymore but from an old experience I think you need to re-load the asset
                        var loadedPart = AssetDatabase.LoadAssetAtPath<PartBase>(path);

                        // add the loaded asset to the "parts" list
                        m_ListProperty.arraySize += 1;
                        var elementProperty = m_ListProperty.GetArrayElementAtIndex(m_ListProperty.arraySize - 1);

                        elementProperty.objectReferenceValue = loadedPart;

                        // finally make the modified SerializedProperties persistent in the actual "Whole" asset
                        m_ListProperty.serializedObject.ApplyModifiedProperties();

                        // [optional] "Ping" the created asset => get highlighted in the Assets folder
                        EditorGUIUtility.PingObject(loadedPart);

                        // Close the popup window
                        Close();
                    }
                }
            }
        }
    }

#endif
}

А вот небольшая демонстрация того, как это будет выглядеть

Для демонстрации я создал следующие типы — конечно, все в своих отдельных файлах скриптов.

public class PartBase : ScriptableObject { }

public class ExamplePart : PartBase { }

namespace NamespaceA
{
    public class PartA : PartBase { }
}

namespace NamespaceA
{
    public class PartAExtended : PartA { }
}

namespace NamespaceB
{
    public class PartB : PartBase { }
}

namespace NamespaceB
{
    public class PartBExtended : PartB { }
}