refactor(javascript): move serialization runtime state into contexts (#3549)

## Why?

- Align the JavaScript runtime ownership model with context-based
operation state instead of ambient `Fory` state.
- Remove internal `Fory` retention from serializers and codegen while
preserving the existing wire format and early-bound closure performance
model.

## What does this PR do?

- Introduces reusable `WriteContext` and `ReadContext` objects and moves
binary reader/writer, ref tracking, meta string handling, and type-meta
state under those contexts.
- Keeps `Fory` as the top-level facade, renames
`registerSerializer(...)` to `register(...)`, removes
`serializeVolatile(...)`, and exports `WriteContext` / `ReadContext` for
custom serializers.
- Refactors `TypeResolver`, `TypeInfo`, codegen, and generated
serializers to stop retaining `Fory` and instead bind hot
reader/writer/resolver locals from resolver-rooted reusable contexts.
- Splits legacy `ReferenceResolver` / `MetaStringResolver` into
directional helpers and folds `TypeMetaResolver` logic into the new
contexts.
- Updates JavaScript docs, benchmark scripts, and tests to the new
context-first custom serializer API without changing serialization
behavior or wire format.
- Normalizes the new JavaScript context/codegen files to satisfy the
repository code style checks.

## Related issues

- None.

## AI Contribution Checklist



- [ ] Substantial AI assistance was used in this PR: `yes` / `no`
- [ ] If `yes`, I included a completed [AI Contribution
Checklist](https://github.com/apache/fory/blob/main/AI_POLICY.md#9-contributor-checklist-for-ai-assisted-prs)
in this PR description and the required `AI Usage Disclosure`.
- [ ] If `yes`, my PR description includes the required `ai_review`
summary and screenshot evidence of the final clean AI review results
from both fresh reviewers on the current PR diff or current HEAD after
the latest code changes.



## Does this PR introduce any user-facing change?

- [x] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?

JavaScript public API changes include `fory.register(...)`, removal of
`serializeVolatile(...)`, and context-first custom serializer
signatures.

## Benchmark

Preserves the existing early-bound closure strategy for generated
serializers; no wire-format change is intended.

Author: chaokunyang

javascript/README.md

@@ -21,7 +21,7 @@ const typeInfo = Type.struct('example.foo', {
   foo: Type.string(),
 });
 const fory = new Fory({ hps });
-const { serialize, deserialize } = fory.registerSerializer(typeInfo);
+const { serialize, deserialize } = fory.register(typeInfo);
 const input = serialize({ foo: 'hello fory' });
 const result = deserialize(input);
 console.log(result);

javascript/benchmark/index.js

@@ -171,7 +171,7 @@ const sample = {
 
 
 const typeinfo = utils.data2TypeInfo(sample, "fory.test.foo");
-const { serialize, deserialize, serializeVolatile } = fory.registerSerializer(typeinfo);
+const { serialize, deserialize } = fory.register(typeinfo);
 
 const foryAb = serialize(sample);
 const sampleJson = JSON.stringify(sample);
@@ -228,7 +228,7 @@ async function start() {
     var suite = new Benchmark.Suite();
     suite
       .add("fory", function () {
-        serializeVolatile(sample).dispose();
+        serialize(sample);
       })
       .add("json", function () {
         JSON.stringify(sample);

javascript/benchmark/map.js

@@ -32,12 +32,12 @@ const Type = Fory.Type;
 
 
 
-const { serialize: serialize1, deserialize: deserialize1, serializeVolatile: serializeVolatile1 } = fory.registerSerializer(Type.struct("any", {
+const { serialize: serialize1, deserialize: deserialize1 } = fory.register(Type.struct("any", {
   f1: Type.map(Type.any(), Type.any()),
   f2: Type.map(Type.any(), Type.any())
 }));
 
-const { serialize: serialize2, deserialize: deserialize2, serializeVolatile: serializeVolatile2 } = fory.registerSerializer(Type.struct("specific", {
+const { serialize: serialize2, deserialize: deserialize2 } = fory.register(Type.struct("specific", {
   f1: Type.map(Type.string(), Type.string()),
   f2: Type.map(Type.int32(), Type.string())
 }));
@@ -58,13 +58,13 @@ async function start() {
     var suite = new Benchmark.Suite();
     suite
       .add("any serialize", function () {
-        serializeVolatile1(sample).dispose()
+        serialize1(sample)
       })
       .add("any deserialize", function () {
         deserialize1(foryAb1)
       })
       .add("jit serialize", function () {
-        serializeVolatile2(sample).dispose()
+        serialize2(sample)
       })
       .add("jit deserialize", function () {
         deserialize2(foryAb2)

javascript/packages/core/index.ts

@@ -27,6 +27,7 @@ import Fory from "./lib/fory";
 import { BinaryReader } from "./lib/reader";
 import { BinaryWriter } from "./lib/writer";
 import { BFloat16, BFloat16Array } from "./lib/bfloat16";
+import { ReadContext, WriteContext } from "./lib/context";
 
 export {
   Serializer,
@@ -38,6 +39,8 @@ export {
   BinaryReader,
   BFloat16,
   BFloat16Array,
+  ReadContext,
+  WriteContext,
 };
 
 export default Fory;