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.
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
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.
remove some unused type cast macros
particle-engine: update to build with latest cogl
autogen.sh: don't refer to removed jni/ directory
rut: Add RutQueue api
osx: s/RigData/RigEngine/
Major iteration across Rig for multi-process architecture

These changes affect a lot of Rig and although ideally, I would have
preferred to split this work into smaller patches, most of the changes
are inter-related and so it would take quite a lot of effort to split up
now.

Note: this work is still not complete, since for example, not all of the
edit operations in rig-engine-op.c have been implemented yet. The idea
is to first verify that the property-set operation works before
completing the other operations.
Adds initial support for code based bindings

This adds initial support for controlling properties via C expressions
that are re-evaluated whenever a declared set of dependencies change.
Dependency properties are made available as variables to the
expressions.

Expression parsing and compilation is implemented using the Clang
compiler frontend, and linking is handled with the MCLinker library.
property: use stdbool instead of CoglBool for boolean types
protobuf-c-dispatch: initialize has_timeout