Not sure if we should go this route or wrap in a callback, I'd prefer
if we can go this route to avoid adding JS wrapping

We're currently keeping a list of trampolines in a static vector, this
is acceptable (at least for a single-context scenario), but trampolines are
bound to a specific context so better to move the handling in the context.

The callback trampoline is in fact a GClosure, but we were just composing
one. We can instead just inherit from it now, given that the
Gjs::Closure will allocate the needed memory via the closure allocator
and handle the references via native closure reference system (avoid to
duplicate that).

As per this, some less memory used as we save a pointer and the
reference counting.

The only bit we need to handle is the destruction as we need to be sure
to call the proper type destructor on closure finalization.
So, adding an utility function that ensures this happens for each type
and that we won't call the base destructor twice.

To create closures we used to create an internal closure structure that
for which we were handling construction and destruction manually.

C++ allows us to use some nicer features though, and we can take
advantage of them once we leave the role of allocating and deallocating
the memory to GClosure functions.

This can be nicely done overriding the new and delete operators that
will give us the size to allocate exactly as the closure creator
function expects to receive.

arg-cache: Never throw when building the argument cache

Closes #386

See merge request GNOME/gjs!590

cppcheck is not smart enough to determine that when we save an allocated
pointer plus an offset, and then free the saved pointer minus that offset,
it amounts to the same thing. But, maybe it is clearer anyway to save the
original pointers and add the offset in an accessor.

Previously, the methods for building the argument cache for a function
could fail, and throw an exception. Normally this was not a problem, since
the argument cache was built when creating the Function object, and that
was generally created right before it was about to be called.

However, static methods are created eagerly when defining a type's
constructor, so if a type contained a method that would throw when
building the argument cache, then merely resolving that type would throw.
(For example, resolving `GLib.ByteArray` would throw.)

Instead, change all the argument cache building methods to be infallible.
If an argument is not supported in GJS, then its in-marshaller throws
instead. This causes the error to happen when the Function object is
called, not when it is created.

In order to give good exception messages, we add a "reason" field to the
GjsArgumentCache union, used by the new gjs_marshal_not_introspectable_in
marshaller, and a display_name() method to GjsFunctionCallState.

Closes: #386

This class is meant to be allocated once, on the stack, and passed by
reference. Copying it would reallocate the in and out C-values arrays,
which would be bad.