simulator: Add support for logging + serializing property changes

This starts adding support for logging all property changes using a
RutMemoryStack in the RutPropertyContext which can be used for
synchronizing property changes made in the Rig simulator process with
the frontend process each frame.

At the end of rig_simulator_run_frame() we now serialize all changed
properties and send them to the frontend process.
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.
start reading property changes in frontend

Adds initial code for sending property changes from the simulator to the
frontend and iterating through those changes in the frontend. Currently
though we don't have a way of looking up object properties using a
property id though, we have to use a name so we'll need to update the
introspectable interface a bit for this.
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.
frontend: apply property changes from the simulator

This makes it so property changes received from the simulator process
are now applied by the frontend. rig-device now no longer dispatches
input events in the frontend and instead relies on the input dispatching
in the simulator process instead.
fix: start reading property changes in frontend
fix: major overhaul of RutType and RutObject
stash: comment about addressing undo-redo issue
path: add missing math.h include
Adds a RutMatrixStack api

This adds a matrix stack utility api based on the CoglMatrixStack api
but not dependant on a CoglContext so it can be used in the rig
simulator process.
stash: starting to get the editor working with the simulator
pb: make rig_pb_serialize_input_events() take serializer

This updates rig_pb_serialize_input_events() to take a serializer
argument and we assume the serialization stack is rewound in
rig_pb_serializer_new().
load-save: fix initialization from incompatible pointer warning
stash
stash
image: calculate aspect as float

This fixes a mistake in rut_image_get_preferred_width/height where it
would sometimes calculate an integer aspect ratio and images that were
wider than they were tall would have a rounded ratio of 0 resulting a
preferred width/height of 0.
stash
stash