Exercise 2: A Recursive Stack Trace, Traced Frame by Frame — Possible Solution
====================================================================

THE PROGRAM
------------------------------
    fun countDown(n) {
        if (n <= 0) {
            return n + "boom";
        }
        return countDown(n - 1);
    }
    print countDown(3);

RESULT
------------------------------
    [line 4] WispRuntimeError: operands of '+' must be two numbers or two strings, got float and str
      at countDown() (called from line 6)
      at countDown() (called from line 6)
      at countDown() (called from line 6)
      at countDown() (called from line 8)
      at <script>

WHY countDown() APPEARS FOUR TIMES
------------------------------
countDown(3) calls countDown(2), which calls countDown(1), which calls
countDown(0) -- four total activations of the same function, each one
its own separate call_stack entry, each pushed by its own call to
WispFunction.call(). The interpreter doesn't collapse or deduplicate
repeated recursive calls to the same function -- every single call,
recursive or not, gets its own (name, call_line) tuple appended to
call_stack, so a function that calls itself N times deep produces
exactly N entries in the trace, one per activation.

WHY THREE ENTRIES SHARE "called from line 6" AND ONE DOESN'T
------------------------------
Line 6 is `return countDown(n - 1);` -- the RECURSIVE call, inside the
function's own body. Line 8 is `print countDown(3);` -- the ORIGINAL,
top-level call that started the whole chain. The three innermost
frames (countDown(2) calling countDown(1), countDown(1) calling
countDown(0), and the failing countDown(0) itself, which is the
frame where the error was actually detected but the call THAT
CREATED IT came from a countDown(1) frame at line 6) all trace back to
line 6, because they were all created by the SAME recursive call
expression, executed multiple times as the recursion unwound one level
each time. Only the outermost frame -- countDown(3), the very first
call -- was created by a genuinely different call expression, the
one at line 8, which only ever executes once.

This is the direct payoff of storing `call_line` per PUSH rather than
per function: `interpreter.call_stack.append((self.declaration.name,
call_line))` runs fresh every time call() is entered, capturing
whatever `node.line` the CURRENT call's own Call node carried at that
specific moment -- so the trace correctly distinguishes "this call
happened at the recursive site" from "this call happened at the
original site," even though every single frame in the whole trace
shares the identical function name.