Read module from scope in machine code executor

This allows us to remove the on stack guard for the normal interpreter
case, because the module now is read again after for dtrace probes. This
prevents an allocation / free in the regular case because of OnStack.
Use OnStack only when neccessary

In the fast case where locking atomically succeeds, we don't need to
mark the object as OnStack. We only need to do this when we potentially
have to wait, so move the guards down to these specific cases where this
might happen.
Move OnStack guard down to where it's needed for autoloads
Remove unneccessary OnStack GC guard
Unlock method table before trying to alias

Otherwise the method table would never be unlocked again.
Also remove require requests for libraries

This prevents these require requests to linger around forever.
Switch to using a vector for tracking locked objects

This improves performance on a lock / unlock benchmark by a factor of
2x. The problem is that std::list allocates memory for every list entry,
so this creates significant overhead if we add and remove linked list
elements often. Switching to a vector removes this overhead, since it
doesn't need to allocate memory on each addition.

We also add a small optimization for which element to remove. Often
locks are used in a stack fashion in code, so often the last element
will be removed in the list because that was also added last. We
optimize for this case so we only have to do the linear search when it's
not the last element.
Don't clear the global interrupt checking when we should GC

This could cause other thread to miss the signaling for an interrupt, so
they would continue to run and not wait for GC. Exposed by the
AtomicReference benchmarks that triggerd this in the busy waiting loop
for a global.