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/Resources/Texture/Texture.cpp

@@ -0,0 +1,40 @@
+#include "Resources/Texture.h"
+#include <cstring>
+
+namespace XCEngine {
+namespace Resources {
+
+Texture::Texture() = default;
+Texture::~Texture() = default;
+
+void Texture::Release() {
+    m_pixelData.Clear();
+    SetInvalid();
+}
+
+bool Texture::Create(Core::uint32 width, Core::uint32 height, Core::uint32 depth,
+                    Core::uint32 mipLevels, TextureType type, TextureFormat format,
+                    const void* data, size_t dataSize) {
+    m_width = width;
+    m_height = height;
+    m_depth = depth;
+    m_mipLevels = mipLevels;
+    m_textureType = type;
+    m_format = format;
+    
+    if (data && dataSize > 0) {
+        m_pixelData.Resize(dataSize);
+        std::memcpy(m_pixelData.Data(), data, dataSize);
+    }
+    
+    m_memorySize = dataSize;
+    
+    return true;
+}
+
+bool Texture::GenerateMipmaps() {
+    return false;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/Texture/TextureImportSettings.cpp

@@ -0,0 +1,23 @@
+#include <XCEngine/Resources/TextureImportSettings.h>
+
+namespace XCEngine {
+namespace Resources {
+
+TextureImportSettings::TextureImportSettings() = default;
+
+TextureImportSettings::~TextureImportSettings() = default;
+
+Core::UniqueRef<ImportSettings> TextureImportSettings::Clone() const {
+    return Core::UniqueRef<ImportSettings>(new TextureImportSettings(*this));
+}
+
+bool TextureImportSettings::LoadFromJSON(const Containers::String& json) {
+    return false;
+}
+
+Containers::String TextureImportSettings::SaveToJSON() const {
+    return Containers::String();
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/Texture/TextureLoader.cpp

@@ -0,0 +1,67 @@
+#include "Resources/TextureLoader.h"
+#include "Resources/ResourceManager.h"
+
+namespace XCEngine {
+namespace Resources {
+
+TextureLoader::TextureLoader() = default;
+TextureLoader::~TextureLoader() = default;
+
+Containers::Array<Containers::String> TextureLoader::GetSupportedExtensions() const {
+    Containers::Array<Containers::String> extensions;
+    extensions.PushBack(Containers::String("png"));
+    extensions.PushBack(Containers::String("jpg"));
+    extensions.PushBack(Containers::String("jpeg"));
+    extensions.PushBack(Containers::String("tga"));
+    extensions.PushBack(Containers::String("bmp"));
+    extensions.PushBack(Containers::String("gif"));
+    extensions.PushBack(Containers::String("hdr"));
+    extensions.PushBack(Containers::String("dds"));
+    return extensions;
+}
+
+bool TextureLoader::CanLoad(const Containers::String& path) const {
+    Containers::String ext = GetExtension(path);
+    ext.ToLower();
+    
+    return ext == "png" || ext == "jpg" || ext == "jpeg" || 
+           ext == "tga" || ext == "bmp" || ext == "gif" || 
+           ext == "hdr" || ext == "dds";
+}
+
+LoadResult TextureLoader::Load(const Containers::String& path, const ImportSettings* settings) {
+    (void)settings;
+    
+    Containers::String ext = GetExtension(path);
+    ext.ToLower();
+    
+    if (!CanLoad(path)) {
+        return LoadResult(Containers::String("Unsupported texture format: ") + ext);
+    }
+    
+    Containers::Array<Core::uint8> fileData = ReadFileData(path);
+    if (fileData.Empty()) {
+        return LoadResult(Containers::String("Failed to read file: ") + path);
+    }
+    
+    auto* texture = new Texture();
+    
+    IResource::ConstructParams params;
+    params.name = path;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    params.memorySize = fileData.Size();
+    
+    texture->Initialize(params);
+    
+    return LoadResult(texture);
+}
+
+ImportSettings* TextureLoader::GetDefaultSettings() const {
+    return nullptr;
+}
+
+REGISTER_RESOURCE_LOADER(TextureLoader);
+
+} // namespace Resources
+} // namespace XCEngine