refactor: reorganize Resources module into Core/Asset, Core/IO and Resources subdirectories

- Split core resource architecture into Core/Asset/ (IResource, ResourceManager, ResourceCache, etc.)
- Moved IO layer into Core/IO/ (IResourceLoader, ResourceFileSystem, etc.)
- Reorganized concrete resource types into Resources/{Texture,Mesh,Material,Shader,AudioClip}/
- Updated all include paths from relative to <XCEngine/...> format
- Fixed circular dependency in Material.h (removed unnecessary ResourceManager.h include)
- Fixed malformed include syntax in ResourceManager.h and AsyncLoader.h
- Fixed glad.h path issues in CMakeLists.txt

engine/src/Core/Asset/AsyncLoader.cpp

@@ -0,0 +1,103 @@
+#include "Resources/AsyncLoader.h"
+#include "Resources/ResourceManager.h"
+#include "Resources/ResourceTypes.h"
+
+namespace XCEngine {
+namespace Resources {
+
+Core::uint64 LoadRequest::GenerateRequestId() {
+    static std::atomic<Core::uint64> s_requestId{0};
+    return ++s_requestId;
+}
+
+AsyncLoader& AsyncLoader::Get() {
+    static AsyncLoader instance;
+    return instance;
+}
+
+void AsyncLoader::Initialize(Core::uint32 workerThreadCount) {
+    (void)workerThreadCount;
+}
+
+void AsyncLoader::Shutdown() {
+    CancelAll();
+}
+
+void AsyncLoader::Submit(const Containers::String& path, ResourceType type,
+                        std::function<void(LoadResult)> callback) {
+    Submit(path, type, nullptr, std::move(callback));
+}
+
+void AsyncLoader::Submit(const Containers::String& path, ResourceType type, ImportSettings* settings,
+                        std::function<void(LoadResult)> callback) {
+    LoadRequest request(path, type, std::move(callback), settings);
+    SubmitInternal(std::move(request));
+}
+
+void AsyncLoader::SubmitInternal(LoadRequest request) {
+    IResourceLoader* loader = FindLoader(request.type);
+    
+    if (!loader) {
+        if (request.callback) {
+            LoadResult result(Containers::String("No loader for type: ") + 
+                           GetResourceTypeName(request.type));
+            request.callback(result);
+        }
+        return;
+    }
+    
+    {
+        std::lock_guard lock(m_queueMutex);
+        m_pendingQueue.PushBack(std::move(request));
+        m_pendingCount++;
+        m_totalRequested++;
+    }
+}
+
+void AsyncLoader::Update() {
+    Containers::Array<LoadRequest> completed;
+    
+    {
+        std::lock_guard lock(m_completedMutex);
+        completed = std::move(m_completedQueue);
+        m_completedQueue.Clear();
+    }
+    
+    for (auto& request : completed) {
+        m_pendingCount--;
+        
+        if (request.callback) {
+            LoadResult result(true);
+            request.callback(result);
+        }
+    }
+}
+
+float AsyncLoader::GetProgress() const {
+    if (m_totalRequested == 0) return 1.0f;
+    return static_cast<float>(m_totalRequested - m_pendingCount.load()) / m_totalRequested;
+}
+
+void AsyncLoader::CancelAll() {
+    std::lock_guard lock(m_queueMutex);
+    m_pendingQueue.Clear();
+    m_pendingCount = 0;
+}
+
+void AsyncLoader::Cancel(Core::uint64 requestId) {
+    std::lock_guard lock(m_queueMutex);
+    (void)requestId;
+}
+
+IResourceLoader* AsyncLoader::FindLoader(ResourceType type) const {
+    return ResourceManager::Get().GetLoader(type);
+}
+
+void AsyncLoader::QueueCompleted(LoadRequest request, LoadResult result) {
+    std::lock_guard lock(m_completedMutex);
+    (void)request;
+    (void)result;
+}
+
+} // namespace Resources
+} // namespace XCEngine