Plugin Registration Changes

- Re-wrote how the plugin registers itself.
- No longer need @register_wrapper classes get auto detected and added.
- The new Auto loader is much better then the old way, no longer need "if "bpy" not in locals():" this was an old way of doing things and wasn't really efficient.

 using auto_load.py provides several advantages:

- It automatically discovers and loads all modules in the addon.
- It handles dependencies between classes correctly through topological sorting.
- It manages registration order automatically.
- It properly handles unregistration in the correct order.

This approach is much less error prone and I not had any issues so far. However it still needs testing fully.

I have also start to re-organise files into folders as well, this is going to be needed so we don't have a long list of files as Avatar Toolkit is getting larger then i originally planned.

core/auto_load.py

@@ -0,0 +1,172 @@
+import os
+import bpy
+import sys
+import typing
+import inspect
+import pkgutil
+import tomllib
+import importlib
+from pathlib import Path
+
+__all__ = (
+    "init",
+    "register",
+    "unregister",
+)
+
+modules = None
+ordered_classes = None
+
+def init():
+    global modules
+    global ordered_classes
+    print("Auto-load init starting")
+    modules = get_all_submodules(Path(__file__).parent.parent)
+    ordered_classes = get_ordered_classes_to_register(modules)
+    print(f"Found modules: {modules}")
+    print(f"Found classes: {ordered_classes}")
+
+def register():
+    print("Registering classes")
+    for cls in ordered_classes:
+        print(f"Registering: {cls}")
+        try:
+            bpy.utils.register_class(cls)
+        except ValueError:
+            continue
+
+    for module in modules:
+        if module.__name__ == __name__:
+            continue
+        if hasattr(module, "register"):
+            module.register()
+
+def unregister():
+    for cls in reversed(ordered_classes):
+        bpy.utils.unregister_class(cls)
+
+    for module in modules:
+        if module.__name__ == __name__:
+            continue
+        if hasattr(module, "unregister"):
+            module.unregister()
+
+def get_manifest_id():
+    manifest_path = Path(__file__).parent.parent / "blender_manifest.toml"
+    with open(manifest_path, "rb") as f:
+        manifest = tomllib.load(f)
+    return manifest["id"]
+
+def get_all_submodules(directory):
+    modules = []
+    addon_id = get_manifest_id()
+    for root, dirs, files in os.walk(directory):
+        if "__pycache__" in root:
+            continue
+        path = Path(root)
+        if path == directory:
+            package_name = f"bl_ext.user_default.{addon_id}"
+        else:
+            relative_path = path.relative_to(directory).as_posix().replace('/', '.')
+            package_name = f"bl_ext.user_default.{addon_id}.{relative_path}"
+        for name in sorted(iter_module_names(path)):
+            modules.append(importlib.import_module(f".{name}", package_name))
+    return modules
+
+def iter_submodules(path, package_name):
+    for name in sorted(iter_module_names(path)):
+        yield importlib.import_module("." + name, package_name)
+
+def iter_module_names(path):
+    print(f"Scanning path: {path}")  # Debug path
+    modules_list = list(pkgutil.iter_modules([str(path)]))
+    print(f"Found these modules: {modules_list}")  # Debug modules
+    for _, module_name, is_pkg in modules_list:
+        if not is_pkg:
+            print(f"Found module: {module_name}")
+            yield module_name
+
+
+
+def get_ordered_classes_to_register(modules):
+    return toposort(get_register_deps_dict(modules))
+
+def get_register_deps_dict(modules):
+    deps_dict = {}
+    classes_to_register = set(iter_classes_to_register(modules))
+    for cls in classes_to_register:
+        deps_dict[cls] = set(iter_own_register_deps(cls, classes_to_register))
+    return deps_dict
+
+def iter_own_register_deps(cls, classes_to_register):
+    yield from (dep for dep in iter_register_deps(cls) if dep in classes_to_register)
+
+def iter_register_deps(cls):
+    for value in typing.get_type_hints(cls, {}, {}).values():
+        dependency = get_dependency_from_annotation(value)
+        if dependency is not None:
+            yield dependency
+
+def get_dependency_from_annotation(value):
+    if isinstance(value, tuple) and len(value) == 2:
+        if value[0] in (bpy.props.PointerProperty, bpy.props.CollectionProperty):
+            return value[1]["type"]
+    return None
+
+def iter_classes_to_register(modules):
+    base_types = get_register_base_types()
+    for cls in get_classes_in_modules(modules):
+        if any(base in base_types for base in cls.__bases__):
+            if not getattr(cls, "_is_registered", False):
+                yield cls
+
+def get_classes_in_modules(modules):
+    classes = set()
+    for module in modules:
+        for cls in iter_classes_in_module(module):
+            classes.add(cls)
+    return classes
+
+def iter_classes_in_module(module):
+    for value in module.__dict__.values():
+        if inspect.isclass(value):
+            yield value
+
+def get_register_base_types():
+    return set(getattr(bpy.types, name) for name in [
+        "Panel", "Operator", "PropertyGroup",
+        "AddonPreferences", "Header", "Menu",
+        "Node", "NodeSocket", "NodeTree",
+        "UIList", "RenderEngine"
+    ])
+
+def toposort(deps_dict):
+    sorted_list = []
+    sorted_values = set()
+    
+    # First pass: Register panels without parents
+    panels_to_sort = [(value, deps) for value, deps in deps_dict.items() 
+                      if hasattr(value, 'bl_parent_id')]
+    
+    base_panels = [(value, deps) for value, deps in deps_dict.items() 
+                   if not hasattr(value, 'bl_parent_id')]
+    
+    # Add base panels first
+    for value, deps in base_panels:
+        if len(deps) == 0:
+            sorted_list.append(value)
+            sorted_values.add(value)
+    
+    # Then add child panels
+    while len(deps_dict) > len(sorted_values):
+        unsorted = []
+        for value, deps in deps_dict.items():
+            if value not in sorted_values:
+                if len(deps - sorted_values) == 0:
+                    sorted_list.append(value)
+                    sorted_values.add(value)
+                else:
+                    unsorted.append(value)
+    
+    return sorted_list
+