Introduce CallSite object

The CallSite is an abstract base class used for example for InlineCache.
Future types of caches could inherit from CallSite as well, for example
for a cache for respond_to?
Add support for custom call sites for respond_to

This sets up a new type of call site for respond_to? calls at the place
where respond_to? is called. Currently it only stores the last symbol
and visibility tag that is has seen and returns the cached value if they
match.
Callsite doesn't need an initializer by default

We also always replace the respond_to cache to prevent thread safety
issues.
Use different way of storing call site information

When we update the call site with a new object object, we need to be
able to through the write barrier for storing the new call site. The
easiest way is to store the compiled code object and the instruction
pointer, so we can use that for storing a new object on the machine code
object.
Teach the JIT about responds_to? caches and inline directly

This inserts a class check and immediately returns the cached value if
it hasn't changed yet.
Move pointer to first slot for call site
Initialize call sites as empty cache
Use single call site validation and setup inline cache

We setup an inline cache for cases where we hit an empty cache in the
serial check, so we see the proper cache the next time.
Extract call site update logic
Setup fallback executor in call site
Introduce MonoInlineCache for monomorphic call sites

This means the current InlineCache will changed to being the
PolyInlineCache for cases of more than one receiver type.
Introduce separate poly method to check method missing

In polymorphic cases we don't always have to check method_missing
status, only if we actually store an entry with method missing. This
removes the need for having to do this check in the common case of not
having this.
Set fallback and write barrier in cache setter

All code goes through set_cache so it should also setup the write
barrier and check whether we have to fallback to doing method missing
checks. This deduplicates this logic in other places.
Disable direct allocation for call sites
Extract call custom cache into separate object

This extracts the call custom cache into a separate call site object.
This also simplifies the logic of setting up the other call site types.
Cleanup debug information from JIT helper
Cleanup unused fallback function pointer
Remove intermediate InlineCacheHit class

Store the hits in the InlineCacheEntry directly instead of having an
additional dereference. This also simplifies JIT logic walking these
structures.
Rename InlineCache to PolyInlineCache

The original InlineCache now functions as the PolyInlineCache with 3
entries at this point. We should investigate whether this is still the
preferred number now that we have split out mono-morphic call sites into
a separate object.
Make new call sites accessible from Ruby land

This allows to grab the call site object and take a peek at it from Ruby
land. This means you can find what it's bound to and how often the
interpreter has called these.