Add new tests and implement frame budget management

- Introduced `civilization_benchmark.gd` and `legacy_quantity_math.gd` for benchmarking and legacy quantity calculations.
- Created `test_dynamic_math.gd`, `test_frame_evolution.gd`, and `test_sparse_batches.gd` to validate mathematical operations and frame evolution logic.
- Implemented `frame_budget.gd` to manage cooperative work on the main thread, ensuring no partially calculated state is published.
- Added UID files for all new scripts to maintain unique identifiers.

tests/test_dynamic_math.gd

@@ -0,0 +1,72 @@
+extends SceneTree
+const E = preload("res://world/owniverse/math/exact.gd")
+const B = preload("res://world/owniverse/math/big_integer.gd")
+var checks: int = 0
+var failures: int = 0
+
+func verify(condition: bool, label: String):
+    checks += 1
+    if not condition:
+        failures += 1
+        push_error(label)
+
+func _initialize():
+    call_deferred("run")
+
+func run():
+    var rng = RandomNumberGenerator.new()
+    rng.seed = 619
+    for trial in 300:
+        var n: int = rng.randi_range(0, 100)
+        var m: int = rng.randi_range(1, 100)
+        var a: int = rng.randi_range(0, 1000)
+        var b: int = rng.randi_range(0, 1000)
+        var expected: int = 0
+        for i in n: expected += (a * i + b) / m
+        verify(E.eq(E.floor_sum(n, a, b, m), expected), "floor sum matches explicit windows")
+    var huge = E.of("1e40")
+    verify(E.lt(E.of("1e1000"), INF), "finite huge number is below positive infinity")
+    verify(E.gt(E.of("-1e1000"), -INF), "finite huge negative number is above negative infinity")
+    verify(E.gt(INF, E.of("1e1000")), "positive infinity is above finite huge number")
+    verify(not E.eq(E.of("1e1000"), INF), "huge number is not infinity")
+    verify(E.eq(E.floor_sum(huge, 2, 1, 2), E.divide(E.multiply(huge, E.subtract(huge, 1)), 2)), "floor sum supports huge window counts")
+    var rows = JSON.parse_string(FileAccess.get_file_as_string("res://tests/fixtures/big_integer_oracle.json"))
+    for row in rows:
+        var a: Array = B.parse(row[0])
+        var b: Array = B.parse(row[1])
+        var qr: Array = B.divmod(a, b)
+        verify(B.decimal(B.add(a, b)) == row[2], "independent big sum")
+        verify(B.decimal(B.multiply(a, b)) == row[3], "independent big product")
+        verify(B.decimal(qr[0]) == row[4], "independent big quotient")
+        verify(B.decimal(qr[1]) == row[5], "independent big remainder")
+        verify(E.fixed(E.multiply(E.of(row[0]), E.of(row[1]))) == row[3], "dynamic product")
+        verify(E.eq(E.mul_div(E.of(row[0]), E.of(row[1]), E.of(row[1])), E.of(row[0])), "fused conservation")
+    for text in ["9223372036854775807", "-9223372036854775808", "9223372036854775808", "-9223372036854775809", "1e300", "1e1000"]:
+        var n = E.of(text)
+        verify(E.eq(E.subtract(E.add(n, 1), n), 1), "unit preserved at " + text)
+        verify(E.eq(E.decode(JSON.parse_string(JSON.stringify(E.encode(n)))), n), "round trip " + text)
+    for text in ["1.25", "-1.25", "123.5"]:
+        verify(E.approx(E.of(text)) == float(text), "approx fraction " + text)
+    verify(not E.valid_encoded({"$exact": [[], "0000000000000000", 1]}), "reject empty blocks")
+    verify(not E.valid_encoded({"$exact": [[1, 0], "0000000000000000", 1]}), "reject noncanonical blocks")
+    verify(E.gt(E.power(E.of("1e400"), -1), 0) == false, "float fraction underflows beyond its range")
+    verify(absf(E.approx(E.logarithm(E.of("1e1000"))) - 1000 * log(10.0)) < 1e-8, "logarithm beyond float range")
+    verify(E.eq(E.square_root(E.of("1e1000")), E.of("1e500")), "square root beyond float range")
+    var world = load("res://world/owniverse/owniverse.gd").new()
+    world.catalog.load_definitions(root.get_node("Global").OwniverseEntities)
+    for id in world.catalog.entities:
+        world.state.amount[id] = 0
+        world.state.stats.total_amount[id] = 0
+        var group: String = world.catalog.entities[id].group_as
+        if group != "":
+            world.state.amount[group] = 0
+            world.state.stats.total_amount[group] = 0
+    world.state.amount.H = E.of("1e1000")
+    world.state.amount.S = E.of("1e1000")
+    var environment: Dictionary = world.environment.stellar_environment(world.state)
+    verify(E.finite(environment.density) and E.gt(environment.density, 0), "huge density remains finite")
+    verify(E.near(environment.blast, 1), "huge geometric ratio stays valid")
+    for entity in world.catalog.entities.values(): entity.free()
+    world.free()
+    print("Dynamic math: %d checks, %d failures" % [checks, failures])
+    quit(1 if failures else 0)