By placing a handle value on several strategic calls in the runtime
we can then later parse a runtime stacktrace, look for the magic
values in function parameters, and reconstruct the calling nodes.

We can use that to filter out all the yaegi runtime calls and
present the user with a stacktrace that includes only interpreted
frames.

this makes the filtered stack look identical to the regular go stacktrace

this allows calling code to interchange both types

interpreter may be entered (for example) from genFunctionWrapper

When a panic happens, we want to get the stack trace from the oldest
panic, before runCfg unwinds everything.

However, at that point we don't know yet whether we will be recovered.
As a silly kludge, currently storing the oldest panic in a list on the
Interpreter struct which can then be queried once we're ready.

The approach taken is not strictly correct: if a panic is recovered, and
never queried, and later the same error occurs again and then is not
recovered, the wrong call stack will be returned.