perf: skip assert super-chain walk for assert-free objects (#698)

## Motivation

When accessing fields on a `Val.Obj`, the evaluator walks the
super-chain to trigger all `assert` statements. For objects without any
assertions (the common case), this walk is wasted work — iterating
through potentially deep inheritance chains for no effect.

## Key Design Decision

Add a `hasAsserts` flag to `Val.Obj` that tracks whether the object or
any of its supers contain assertions. Skip the super-chain walk entirely
when `hasAsserts == false`.

## Modification

- **`Val.scala`**: Added `hasAsserts` flag, propagated through object
merge (`+`)
- **`Evaluator.scala`**: Guard assert walk with `hasAsserts` check
- **Test**: Added test for assert-free objects and objects with asserts
to verify both paths

## Benchmark Results

### JMH (JVM, 3 iterations)

| Benchmark | Master (ms/op) | This PR (ms/op) | Change |
|-----------|---------------|-----------------|--------|
| bench.02 | 50.427 ± 38.906 | 47.337 ± 2.780 | **-6.1%** |
| **comparison2** | **85.854 ± 188.657** | **67.984 ± 33.584** |
**-20.8%** 🔥 |
| **realistic2** | **73.458 ± 66.747** | **67.857 ± 11.936** | **-7.6%**
✅ |

## Analysis

- **comparison2**: Largest improvement — this benchmark creates many
small objects without assertions, so skipping the assert walk saves
significant time
- **realistic2**: Also benefits from reduced per-field-access overhead
- Safe optimization: objects with assertions still execute them
correctly
- No regressions

## References

- Upstream exploration: `he-pin/sjsonnet` jit branch commit `85ca07ca`

## Result

-7% to -21% JVM improvement by skipping unnecessary assert super-chain
walks for assertion-free objects.

Author: He-Pin

sjsonnet/src/sjsonnet/Val.scala

@@ -459,6 +459,11 @@ object Val {
       with Expr.ObjBody {
     private[sjsonnet] def valTag: Byte = TAG_OBJ
     private var asserting: Boolean = false
+    // Pre-computed flag: true if this object or any super has assert statements.
+    // Computed O(1) at construction from the super chain (super is already constructed).
+    // Allows skipping the triggerAllAsserts super-chain walk for assert-free objects.
+    private val hasAnyAsserts: Boolean =
+      triggerAsserts != null || (`super` != null && `super`.hasAnyAsserts)
 
     def getSuper: Obj = `super`
 
@@ -485,9 +490,8 @@ object Val {
     }
 
     def triggerAllAsserts(brokenAssertionLogic: Boolean): Unit = {
-      // We need to avoid asserting the same object more than once to prevent
-      // infinite recursion
-      if (!asserting) {
+      // Short-circuit: no asserts in this object or any super
+      if (hasAnyAsserts && !asserting) {
         asserting = true
         triggerAllAsserts(this, `super`, brokenAssertionLogic)
       }