refactor: reorganize package structure and decouple framework packages (#338)

* refactor: reorganize package structure and decouple framework packages

## Package Structure Reorganization
- Reorganized 55 packages into categorized subdirectories:
  - packages/framework/ - Generic framework (Laya/Cocos compatible)
  - packages/engine/ - ESEngine core modules
  - packages/rendering/ - Rendering modules (WASM dependent)
  - packages/physics/ - Physics modules
  - packages/streaming/ - World streaming
  - packages/network-ext/ - Network extensions
  - packages/editor/ - Editor framework and plugins
  - packages/rust/ - Rust WASM engine
  - packages/tools/ - Build tools and SDK

## Framework Package Decoupling
- Decoupled behavior-tree and blueprint packages from ESEngine dependencies
- Created abstracted interfaces (IBTAssetManager, IBehaviorTreeAssetContent)
- ESEngine-specific code moved to esengine/ subpath exports
- Framework packages now usable with Cocos/Laya without ESEngine

## CI Configuration
- Updated CI to only type-check and lint framework packages
- Added type-check:framework and lint:framework scripts

## Breaking Changes
- Package import paths changed due to directory reorganization
- ESEngine integrations now use subpath imports (e.g., '@esengine/behavior-tree/esengine')

* fix: update es-engine file path after directory reorganization

* docs: update README to focus on framework over engine

* ci: only build framework packages, remove Rust/WASM dependencies

* fix: remove esengine subpath from behavior-tree and blueprint builds

ESEngine integration code will only be available in full engine builds.
Framework packages are now purely engine-agnostic.

* fix: move network-protocols to framework, build both in CI

* fix: update workflow paths from packages/core to packages/framework/core

* fix: exclude esengine folder from type-check in behavior-tree and blueprint

* fix: update network tsconfig references to new paths

* fix: add test:ci:framework to only test framework packages in CI

* fix: only build core and math npm packages in CI

* fix: exclude test files from CodeQL and fix string escaping security issue

packages/physics/rapier2d/src/coarena.ts

@@ -0,0 +1,70 @@
+export class Coarena<T> {
+    fconv: Float64Array;
+    uconv: Uint32Array;
+    data: Array<T>;
+    size: number;
+
+    public constructor() {
+        this.fconv = new Float64Array(1);
+        this.uconv = new Uint32Array(this.fconv.buffer);
+        this.data = new Array<T>();
+        this.size = 0;
+    }
+
+    public set(handle: number, data: T) {
+        let i = this.index(handle);
+        while (this.data.length <= i) {
+            this.data.push(null);
+        }
+
+        if (this.data[i] == null) this.size += 1;
+        this.data[i] = data;
+    }
+
+    public len(): number {
+        return this.size;
+    }
+
+    public delete(handle: number) {
+        let i = this.index(handle);
+        if (i < this.data.length) {
+            if (this.data[i] != null) this.size -= 1;
+            this.data[i] = null;
+        }
+    }
+
+    public clear() {
+        this.data = new Array<T>();
+    }
+
+    public get(handle: number): T | null {
+        let i = this.index(handle);
+        if (i < this.data.length) {
+            return this.data[i];
+        } else {
+            return null;
+        }
+    }
+
+    public forEach(f: (elt: T) => void) {
+        for (const elt of this.data) {
+            if (elt != null) f(elt);
+        }
+    }
+
+    public getAll(): Array<T> {
+        return this.data.filter((elt) => elt != null);
+    }
+
+    private index(handle: number): number {
+        /// Extracts the index part of a handle (the lower 32 bits).
+        /// This is done by first injecting the handle into an Float64Array
+        /// which is itself injected into an Uint32Array (at construction time).
+        /// The 0-th value of the Uint32Array will become the `number` integer
+        /// representation of the lower 32 bits.
+        /// Also `this.uconv[1]` then contains the generation number as a `number`,
+        /// which we don’t really need.
+        this.fconv[0] = handle;
+        return this.uconv[0];
+    }
+}