fix: make Frame.lookup() iterative to prevent StackOverflowError

Java does not optimize tail calls. On JVMs with smaller default thread
stack sizes (e.g. Windows workers, containers with -Xss256k), deeply
nested JSONata expressions cause Jsonata$Frame.lookup() to overflow the
stack via tail recursion. StackOverflowError is a JVM Error — it cannot
be safely caught and the entire worker thread crashes.

Replace the recursive parent.lookup(name) call with an iterative loop
over the scope chain. Semantics are identical; traversal order is
unchanged. Eliminates all stack risk from scope chain lookup regardless
of nesting depth.

Fixes worker crashes reported in kestra-io/plugin-transform#79.

Author: fdelbrayelle

src/main/java/com/dashjoin/jsonata/Jsonata.java

@@ -89,12 +89,11 @@ public void bind(String name, JFunction function) {
         public<A,B,R> void bind(String name, Fn2<A,B,R> lambda) { bind(name, (Object)lambda); }
 
         public Object lookup(String name) {
-            // Important: if we have a null value,
-            // return it
-            if (bindings.containsKey(name))
-                return bindings.get(name);
-            if (parent!=null)
-                return parent.lookup(name);
+            // Iterative walk of the parent scope chain to avoid StackOverflowError
+            // on JVMs with small thread stacks (e.g. Windows workers).
+            for (Frame f = this; f != null; f = f.parent) {
+                if (f.bindings.containsKey(name)) return f.bindings.get(name);
+            }
             return null;
         }