Add comprehensive tests and optimizations for simulation and UI performance

- Introduced a new benchmark save script to create a stress test scenario with extreme values for simulation performance.
- Added a full UI benchmark script to measure frame rates and performance metrics during UI interactions.
- Implemented tests for coarse generations to ensure population transitions are handled correctly.
- Created tests for extra parameters to validate the loading and application of configuration settings.
- Developed simulation optimization tests to verify the efficiency of population drift and rounding mechanisms.
- Added split optimization tests to ensure accurate allocation and rounding behavior in population management.
- Included startup parameter tests to confirm the correct initialization of global parameters before scene readiness.
- Enhanced the audit rounding ledger to compare selective and full rounding results for consistency.

tests/test_split_optimizations.gd

@@ -0,0 +1,66 @@
+extends SceneTree
+const E = preload("res://world/owniverse/math/exact.gd")
+const Q = preload("res://world/owniverse/quantity_math.gd")
+var checks: int = 0
+var failures: int = 0
+func _initialize(): call_deferred("run")
+func check(value: bool, message: String):
+    checks += 1
+    if not value:
+        failures += 1
+        push_error(message)
+static func reference_split(remainders: Dictionary, key: String, count: Variant, weights: Dictionary) -> Dictionary:
+    var result: Dictionary = {}
+    var sum_weights: Variant = Q.sum(weights)
+    if (E.le(count, 0) or E.le(sum_weights, 0)): return result
+    var ids: Array = weights.keys()
+    var expected: Array = []
+    var remainder_keys: Array = []
+    var positive_sum: Variant = 0
+    for id in ids:
+        var remainder_key: String = key + ":" + str(id)
+        remainder_keys.append(remainder_key)
+        var value: Variant = E.add(E.mul_div(count, weights[id], sum_weights), remainders.get(remainder_key, 0))
+        expected.append(value)
+        positive_sum = E.add(positive_sum, E.maximum(0, value))
+    var order: Array = []
+    var rests: Array = []
+    var assigned: Variant = 0
+    for i in ids.size():
+        var normalized: Variant = E.mul_div(E.maximum(0, expected[i]), count, positive_sum) if E.gt(positive_sum, 0) else 0
+        result[ids[i]] = E.floor_value(normalized)
+        assigned = E.add(assigned, result[ids[i]])
+        rests.append(E.subtract(normalized, result[ids[i]]))
+        order.append(i)
+    order.sort_custom(func(a: int, b: int) -> bool: return E.gt(rests[a], rests[b]) if E.ne(rests[a], rests[b]) else str(ids[a]) < str(ids[b]))
+    for i in order:
+        if E.ge(assigned, count): break
+        result[ids[i]] = E.add(result[ids[i]], 1)
+        assigned = E.add(assigned, 1)
+    for i in ids.size():
+        remainders[remainder_keys[i]] = E.clamp_value(E.subtract(expected[i], result[ids[i]]), E.neg(1), 1)
+    return result
+
+func run():
+    for count in [0, 1, 7, E.of("1.375"), 1000000, E.of("1e40"), E.of("1e80")]:
+        for weights in [{}, {"a": 0, "b": 0}, {"a": 0, "b": 7}, {"b": 0, "a": 7}, {"a": 1, "b": 1, "c": 1}, {"a": E.of("0.017"), "b": E.of("0.333333333333"), "c": 0}, {"a": E.of("1e40"), "b": 17, "c": 1}]:
+            for carry in [0, E.of("0.25"), E.of("-0.75")]:
+                var actual: Dictionary = {"case:a": carry}
+                var expected: Dictionary = actual.duplicate(true)
+                for iteration in 5:
+                    var reference: Dictionary = reference_split(expected, "case", count, weights)
+                    var result: Dictionary = Q.split(actual, "case", count, weights)
+                    check(E.eq(result, reference), "Split preserves allocation")
+                    check(E.eq(actual, expected), "Split preserves rounding carries")
+    for a in [0, 7, E.of("1e40"), E.of("-1e40"), E.of("1.375")]:
+        var values: Array = [0, 1, -7, E.of("0.017"), E.of("1e30")]
+        for divisor in [1, 3, E.of("0.017"), E.of("1e40")]:
+            var results: Array = E.mul_div_many(a, values, divisor)
+            for i in values.size(): check(E.eq(results[i], E.mul_div(a, values[i], divisor)), "Grouped ratios preserve scalar results")
+    for count in [1, 7, 1000000000, E.of("1e40"), E.of("1e80")]:
+        for factor in [200, 1000]:
+            var weights: Array = [0, 17, E.of("1e40"), E.multiply(count, factor)]
+            var results: Array = E.population_quotas(count, weights, factor)
+            for i in weights.size(): check(E.eq(results[i], E.mul_div(count, weights[i], E.multiply(count, factor))), "Cancelled population preserves exact scalar quotas")
+    print("Split optimizations: %d checks, %d failures" % [checks, failures])
+    quit(1 if failures else 0)