docs: 重构 API 文档结构并修正源码准确性

- 重组文档目录结构: 每个模块的概述页移动到模块子目录
- 重命名 index.md 为 main.md
- 修正所有模块文档中的错误:
  - math: FromEuler→FromEulerAngles, TransformDirection 包含缩放, Box 是 OBB, Color::ToRGBA 格式
  - containers: 新增 operator==/!= 文档, 补充 std::hash DJB 算法细节
  - core: 修复 types 链接错误
  - debug: LogLevelToString 返回大写, timestamp 是秒, Profiler 空实现标注, Windows API vs ANSI
  - memory: 修复头文件路径, malloc vs operator new, 新增方法文档
  - resources: 修复 Shader/Texture 链接错误
  - threading: TaskSystem::Wait 空实现标注, ReadWriteLock 重入描述, LambdaTask 链接
- 验证: fix_links.py 确认 0 个断裂引用

docs/api/memory/pool-allocator/allocate.md

@@ -0,0 +1,37 @@
+# PoolAllocator::Allocate
+
+```cpp
+void* Allocate(size_t size, size_t alignment = 0) override;
+```
+
+从内存池中分配一个空闲块。此方法忽略 `size` 参数，始终分配一个固定大小的块。如果池中没有空闲块，返回 `nullptr`。分配操作从空闲链表头部取出一个块。
+
+**参数：**
+- `size` - 被忽略（始终分配固定块大小）
+- `alignment` - 被忽略（构造时确定）
+
+**返回：** 分配成功返回块指针，池空返回 `nullptr`
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int) * 100, 50, alignof(int));
+
+// 分配（忽略 size 参数）
+void* block1 = pool.Allocate(1);     // 分配 1 字节
+void* block2 = pool.Allocate(10000); // 也分配一块
+
+if (block1 && block2) {
+    // 使用分配的内存块
+    int* arr = static_cast<int*>(block1);
+    arr[0] = 42;
+}
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/contains.md

@@ -0,0 +1,38 @@
+# PoolAllocator::Contains
+
+```cpp
+bool Contains(void* ptr) const;
+```
+
+检查给定的指针是否属于此内存池的地址范围。由于池在构造时预分配连续内存，可通过指针地址区间判断所有权。此方法用于调试和内存验证。
+
+**参数：**
+- `ptr` - 要检查的指针
+
+**返回：** 指针属于此池返回 `true`，否则返回 `false`
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+void* inside = pool.Allocate();
+void* outside = ::operator new(sizeof(int));
+
+if (pool.Contains(inside)) {
+    // inside 属于此内存池，可以安全 Free
+}
+
+if (!pool.Contains(outside)) {
+    // outside 不属于此池，不能调用 pool.Free()
+    ::operator delete(outside);
+}
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/free.md

@@ -0,0 +1,38 @@
+# PoolAllocator::Free
+
+```cpp
+void Free(void* ptr) override;
+```
+
+将内存块归还到空闲链表中。如果 `ptr` 为 `nullptr` 则无效果。释放操作将块插入空闲链表头部。必须传入从此池分配的指针，传入外部指针会导致未定义行为。
+
+**参数：**
+- `ptr` - 指向要释放的内存块
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+void* block = pool.Allocate();
+if (block) {
+    int* num = static_cast<int*>(block);
+    *num = 123;
+    
+    pool.Free(block); // 归还到空闲链表
+    block = nullptr;
+}
+
+// 检查空闲块数量
+size_t freeCount = pool.GetFreeBlockCount();
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-block-size.md

@@ -0,0 +1,31 @@
+# PoolAllocator::GetBlockSize
+
+```cpp
+size_t GetBlockSize() const;
+```
+
+返回内存池中每个内存块的大小。此值在构造时确定，之后保持不变。
+
+**参数：** 无
+
+**返回：** 每个内存块的字节大小
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int) * 100, 50);
+
+size_t blockSize = pool.GetBlockSize(); // 400 字节
+
+void* block = pool.Allocate();
+int* arr = static_cast<int*>(block);
+// arr 指向的大小为 blockSize 字节的内存块
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-free-block-count.md

@@ -0,0 +1,40 @@
+# PoolAllocator::GetFreeBlockCount
+
+```cpp
+size_t GetFreeBlockCount() const;
+```
+
+返回当前空闲块的的数量。每次 `Allocate` 成功后减 1，每次 `Free` 后加 1。
+
+**参数：** 无
+
+**返回：** 当前可分配的空闲块数量
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+size_t initial = pool.GetFreeBlockCount(); // 100
+
+void* blocks[10];
+for (int i = 0; i < 10; ++i) {
+    blocks[i] = pool.Allocate();
+}
+
+size_t after = pool.GetFreeBlockCount(); // 90
+
+for (int i = 0; i < 5; ++i) {
+    pool.Free(blocks[i]);
+}
+
+size_t final = pool.GetFreeBlockCount(); // 95
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-total-block-count.md

@@ -0,0 +1,34 @@
+# PoolAllocator::GetTotalBlockCount
+
+```cpp
+size_t GetTotalBlockCount() const;
+```
+
+返回内存池中的总块数。此值在构造时确定，之后保持不变。
+
+**参数：** 无
+
+**返回：** 内存池的总块数
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+size_t total = pool.GetTotalBlockCount(); // 100
+size_t free = pool.GetFreeBlockCount();  // 100
+
+void* block = pool.Allocate();
+size_t freeAfter = pool.GetFreeBlockCount(); // 99
+
+pool.Free(block);
+size_t freeRestored = pool.GetFreeBlockCount(); // 100
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/pool-allocator.md

@@ -0,0 +1,44 @@
+# PoolAllocator::PoolAllocator / ~PoolAllocator
+
+```cpp
+PoolAllocator(size_t blockSize, size_t poolSize, size_t alignment = 8);
+~PoolAllocator() override;
+```
+
+构造内存池分配器，预分配 `poolSize` 个大小为 `blockSize` 字节的内存块。内存块按 `alignment` 对齐（默认 8 字节）。内部维护一个空闲块链表来管理分配。析构函数释放整个内存池。
+
+**参数：**
+- `blockSize` - 每个内存块的大小（字节）
+- `poolSize` - 内存池中总块数
+- `alignment` - 对齐要求，默认为 8
+
+**返回：** 无
+
+**复杂度：** O(n)，需要预分配所有块
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+struct Particle {
+    float x, y, z;
+    float vx, vy, vz;
+    float life;
+};
+
+// 创建一个能容纳 1000 个 Particle 的内存池，16 字节对齐
+PoolAllocator pool(sizeof(Particle), 1000, alignof(Particle));
+
+size_t blockSize = pool.GetBlockSize();   // sizeof(Particle)
+size_t total = pool.GetTotalBlockCount(); // 1000
+size_t free = pool.GetFreeBlockCount();   // 1000
+
+// 分配和释放
+void* block = pool.Allocate();
+pool.Free(block);
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/reallocate.md

@@ -0,0 +1,35 @@
+# PoolAllocator::Reallocate
+
+```cpp
+void* Reallocate(void* ptr, size_t newSize) override;
+```
+
+内存池分配器不支持重新分配。此方法始终返回 `nullptr`，原内存块保持不变。
+
+**参数：**
+- `ptr` - 不被使用
+- `newSize` - 不被使用
+
+**返回：** 始终返回 `nullptr`
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+void* block = pool.Allocate();
+
+// Reallocate 不支持
+void* newBlock = pool.Reallocate(block, 256);
+if (!newBlock) {
+    // 内存池不支持重新分配
+    // 原 block 仍然有效
+}
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览