feat: 实现Containers、Memory、Threading核心模块及单元测试

- Containers: String, Array, HashMap 容器实现及测试
- Memory: Allocator, LinearAllocator, PoolAllocator, ProxyAllocator, MemoryManager 实现及测试
- Threading: Mutex, SpinLock, ReadWriteLock, Thread, Task, TaskSystem 实现及测试
- 修复Windows平台兼容性: _aligned_malloc, std::hash特化
- 修复构建错误和测试用例问题

engine/src/Threading/TaskGroup.cpp

@@ -0,0 +1,74 @@
+#include "Threading/TaskSystem.h"
+#include "Threading/LambdaTask.h"
+
+namespace XCEngine {
+namespace Threading {
+
+TaskGroup::TaskGroup() = default;
+
+TaskGroup::~TaskGroup() = default;
+
+uint64_t TaskGroup::AddTask(std::unique_ptr<ITask> task) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    
+    TaskNode node;
+    node.task = task.get();
+    node.pendingDepCount = static_cast<int>(node.dependencies.size());
+    
+    uint64_t taskId = m_tasks.size();
+    m_tasks.emplace_back(std::move(node));
+    m_pendingCount++;
+    
+    task.release();
+    return taskId;
+}
+
+uint64_t TaskGroup::AddTask(Callback&& func, TaskPriority priority) {
+    auto task = std::make_unique<LambdaTask<Callback>>(std::move(func), priority);
+    return AddTask(std::move(task));
+}
+
+void TaskGroup::AddDependency(uint64_t taskId, uint64_t dependsOn) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (taskId < m_tasks.size() && dependsOn < m_tasks.size()) {
+        m_tasks[taskId].dependencies.push_back(dependsOn);
+    }
+}
+
+void TaskGroup::Wait() {
+    std::unique_lock<std::mutex> lock(m_mutex);
+    m_condition.wait(lock, [this] { return m_pendingCount.load() == 0; });
+}
+
+bool TaskGroup::WaitFor(std::chrono::milliseconds timeout) {
+    std::unique_lock<std::mutex> lock(m_mutex);
+    return m_condition.wait_for(lock, timeout, [this] { return m_pendingCount.load() == 0; });
+}
+
+void TaskGroup::SetCompleteCallback(Callback&& callback) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_completeCallback = std::move(callback);
+}
+
+bool TaskGroup::IsComplete() const {
+    return m_pendingCount.load() == 0;
+}
+
+float TaskGroup::GetProgress() const {
+    int total = m_tasks.size();
+    if (total == 0) return 1.0f;
+    return static_cast<float>(m_completedCount.load()) / static_cast<float>(total);
+}
+
+void TaskGroup::Cancel() {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_canceled = true;
+    for (auto& node : m_tasks) {
+        if (node.task && !node.completed) {
+            node.task->OnCancel();
+        }
+    }
+}
+
+} // namespace Threading
+} // namespace XCEngine