fix: memory-stack: _memalign(), free sub-stacks, _foreach_region()
fix: memory-stack: _memalign(), free sub-stacks, _foreach_region()
reorganise engine, frontend and simulator relationships

RigFrontend and RigSimulator are now conceptually more of a top-level objects
than RigEngine. rig-simulator owns the RigSimulator state and creates a
RigEngine which hangs of the simulator. rig-device, rig-slave and rig
(editor) now create RigFrontend objects instead of directly creating a
RigEngine.

We should look out for opportunities to migrate state from RigEngine
into other objects like RigSimulator, RigFrontend, RigDevice, RigSlave
and RigEditor.
Add a RutMagazine utility api

This adds a simple, but very fast memory allocation api for allocating
objects of a pre-determined size.

This allocator builds on RutMemoryStack for making all initial
allocations but never frees memory back to the stack.

Memory chunks that haven't been allocated yet are stored in a singly
linked, fifo, list.

Allocating from a magazine is simply a question of popping an entry from
the head of the fifo list. If no entries are available then instead
allocate from the memory stack instead.

When an entry is freed, it is put back into the fifo list for re-use.

No attempt is ever made to shrink the amount of memory associated with a
RutMagazine.
stash: start reading property changes in frontend
major overhaul of RutType and RutObject

The renames the widespread use of the term "interface" in Rut with
"trait". This is inspired by the Rust language whose trait model seems
similar to our mix-in model. The term interface was starting to seem
misleading.

This adds the ability for each trait of an object to optionally have a
corresponding destructor. This is because it's easier to forget to clean
up state for a trait in the _free function which it's disconnected from
the code that adds the trait. It's also just more convenient.

This adds the ability to associate a type with a RutMagazine for faster
allocation performance and also better data locality for objects of the
same type.

This gets rid of the refable interface and moves the ref_count into the
base object. This removes quite a bit of unnecessary indirection and
reduces the boilerplate needed when creating new types.

This removes the need for _rut_init() since all types are now
initialized lazily in the same way.
introspectable: simplify + allow _get_property with id

This consolidates RUT_TRAIT_ID_INTROSPECTABLE and
RUT_TRAIT_ID_SIMPLE_INTROSPECTABLE into one _ID_INTROSPECTABLE trait for
simplicity which also allows us to assume now that all introspectables
simply have a packed array of properties and we can therefore support
looking up a property with an id.

This will be useful for synchronizing property changes from the Rig
simulator process with the frontend process since it lets us efficiently
serialize property changes based on property ids instead of names.