Incorrect behavior of caller instruction for dynamic calls

[bobbinth]

Currently, dyncall instruction translates into two operations in the VM: call dyn. This works mostly fine, but it does result in caller instruction returning an unintuitive (and probably wrong) value.

Specifically, the caller instruction should return the MAST root of the context we are currently in. So, if we do something like:

proc.foo
    caller
    # => [MAST_ROOT_OF_FOO, ...]
end

begin
    call.foo
end

But, if we use dyncall instruction, the result will be different:

proc.foo
    caller
    # => [HASH_DYN_NODE, ...]
end

begin
    procref.foo
    dyncall
end

This is because when we execute the call instruction, we set the MAST root of the new context to the hash of the callee. In case of dyncall, the callee is just a single dyn node - so, that's what gets used to set the MAST root.

Off the top of my head, there are two ways to fix this:

1. Update the semantics of the call operation to check if the next operation is dyn, and if so, use the top of the stack to set the MAST root. This may result in pretty complicated constraints - so, not sure if it will be worth it.
2. Introduce a new dedicate operation for dyncall. This will behave basically like call operation except it will use the top of the stack to set the MAST root of the context. I think dyncall will need to be a "very high degree" operation, and so we can do this only after we free up one of such operation slots (i.e., after #1457).