Delete VM backtrace if allocated

Fixes a memory leak that happened when these exceptions were created
with a backtrace.
Something is up with these tests causing issues

The tests here seem to want to deallocate invalid data, so we disable
them for now to investigate this properly.
Setup proper copy constructor for VMException

The tests depended on a properly working copy constructor, so we create
a proper one that also duplicates the reason and backtrace vector as
needed.
Also mark data as freed when no data pointer is associated

We should mark this data as freed anyway for this case so we don't crash
if we encounter double free's due to issues such as this:

https://github.com/sparklemotion/nokogiri/pull/895

Fixes #2340
Use faster handle validation mechanism

The handle allocator already has a faster way of validating whether a
handle is valid, so we should use that instead of iterating all handles.

This improves performance for JSON entries, since they use
rb_gc_mark_maybe extensively. In a Sidekiq demo app, this validation
took around 3% of the total runtime, with this change it was reduced to
almost nothing.
Track fiber data in a set instead of list

When deleting an item, having a list was having bad performance effects
since the whole list needs to be walked. Since this data structure is
only used to add and remove entries a set is a much better data
structure than a list for this purpose.
Elide type check for all fixnums
Improve JIT by only inlining potentially used code

When we know the receiver type (due to a previous method being inline
for example), we shouldn't inline methods that can never run anyway.
Case where this is important is for example for BasicObject#!=. This is
a megamorphic call site because every case of != flows through it.

However, the methods calling != often aren't megamorphic, just poly or
even monomorphic. This means that if that call site inlines
BasicObject#!=, it only needs to consider the types it is inlining the
parent for.

Because for the parent we attach the type to each of the paths, we can
reuse that type down here and only emit code for cases that are
sensible.

A small code snippet to illustrate this:

def method(arg)
  arg != nil
end

method(1)

The call site where BasicObject#!= is called here is monomorphic,
because it's only called with 1. So the receiver is always a Fixnum.
This means we can inline the implementation of BasicObject#!= with a
fixed Fixnum receiver type.

JIT log before this change:

JIT: compiling block in __block__ near jit_not_equal.rb:6
| inlining: Object#method into __block__
|| inlining: BasicObject#!= into method (Fixnum)
||+ eliding guard: detected static fixnum
||| inlining: Fixnum#== into !=. primitive fixnum_compare_operation
||| inlining: Kernel#equal? into !=. primitive object_equal
||| inlining: String#== into !=. generic primitive: jit_stub_string_equal

JIT log after this change:

JIT: compiling block in __block__ near jit_not_equal.rb:6
| inlining: Object#method into __block__
|| inlining: BasicObject#!= into method (Fixnum)
||+ eliding guard: detected static fixnum
||| inlining: Fixnum#== into !=. primitive fixnum_compare_operation

As can be seen from this log, the JIT is able to see that inlining
Kernel#equal? and String#== here is useless and doesn't do this anymore.
This means that we have fewer type guards now and smaller code size
which also helps for generating more useful code within the inlining
budget.
Fix type for iterator