Add generic closure creation method core.marshal.callback()
Store type to objects as userdata into proxy tables

Apart from speedup by avoiding type-search for every access of any
type instance, this also allows overriding type for specific instances
and is thus base for implementing sane syntax for virtual method
chaining.
Get rid of cache for callable objects

It was not effective because clients weren't duping objects, and broke
when creating dynamic callables from dynamic addresses.
Convert NULL callbacks to 'nil'.

Previously we created callable object which just crashed upon call.
Yielding 'nil' instead not only avoids crash, but also allows easier
testing of NULL (e.g. when chaining up to parent vtable methods).
Avoid circular dependency

When trying to use ffi in class.lua, circular dependency occured.
Avoid error in error reporting
Make record's _resolve() work recursively for records with parents
Avoid global access in cairo override
FFI records: avoid keeping parent for by-ref substructs
Add _index_<category> optional handlers for components
Avoid sinking input argument calls

Sinking input argument objects wreaks havoc to virtual functions
called during object construction (i.e. constructor(), init() and
constructed()) when constructing InitiallyUnowned descendant, because
sinking them during construction means that g_object_new() returns
already sunk object, which is quite unexpected and breaks things.
Add support for tying user_data to callbacks

This allows Lua-implementing virtual functions and callbacks which
take another callbacks and user-data context for it as arguments.  The
prime example is Gtk.Contatiner.forall() vfunc.
Gtk: Small fixes and extensions to Gtk override
Fix handling if closures with output arguments

Previous implementation was based on invalid assumption that output
values are stored backs to GValue arguments.  In reality, output
values are filled into slots pointed to by GValue of gpointer type.
Revamp GObject.Closure accordingly, implement helper inside
marshal (wrapper for allocating/marshalling GIArgument from Lua-side).
Gdk: add convenience mode for Gdk.RGBA.parse()

Add 'constructing' version of Gdk.RGBA.parse() which creates new
Gdk.RGBA instance and returns it, or returns 'nil' if parsing fails.
Gdk: add override for Gdk.Window.destroy(), which consumes 'self' arg

Gdk API is crazy - gdk_window_destroy() MUST be called (unref itself
is not enough), and not only that, it also consumes its 'self'
argument.  This wreaks havoc on any automatic binding.  Solve it by
overload of destroy() which ref()s self before calling destroy().
Fix handling of callback output arguments

Output arguments marshalling did not take into account the one
additional step of indirection (because output arguments are passed as
input pointers to values in C).
Fix handling of GValue passing by value

Previous lgi naive handling of record by-value copying using memcpy
simply did not work for GValue, and this brokenness was just hidden by
another bug - leak caused that g_value_unset was never called.  Oops.
Fix both problems by registering custom _unset and _copy handlers for
Value, add support for these handlers in C core part.
Avoid messing unspecified closure returns with temporary marshalling slots

Calling closure which expects output arguments but does not get any
was trying to marshal C outputs from temporary marshalling stack slots
instead of passing NULL for them.
Fix signal:emit(), add emission by signal call

"self.on_signal:emit(...)" was broken, during repair also add an
alternative syntax "self:on_signal(...)".