model: Implement the lapped texture mapping method
mode: avoid allocating temporary vertices on the heap

This updates the rut-model code rely on stack allocated Vertex
structures to hold intermediate results when generated patched
meshes. This updates the various calculate_ functions to take a pointer
to a vertex for storing the result instead of having those functions
allocate a new vertex via g_new
hair: Improved hair implementation using fins

Implemented a particle engine for the hair so it appears "messy". Added
fin geometry and texture generation to decrease the aliasing around the
mesh silhouette. Applied gaussian blur to each hair strand for realistic
hair coloring. Made use of the patched texture capabilities to ensure
shell textures don't stretch.

NOTE: This patch forces all models to default to lapped texture mapping.
Furthermore fins are only supported for imported models, not built-in
geometry.
pointalism: avoid calling rut_entity_set_primitive_cache

This avoids directly calling rut_entity_set_primitive_cache from
rut-pointalism-grid so that the code doesn't need to know details of the
rendering code. The plan is to make the primitive-cache private to the
renderer.
renderer: move entity caches to renderer priv state

This removes all the caches associated with entities used for caching
state relating to rendering, such as CoglPipelines into the
RigRendererPriv state.
model: no need to use pow() for ^2

Although it's very likely the compiler will recognise the simple case of
pow(x, 2) and optimize it, this just expands the use of pow(x, 2) to
square each component manually. This is probably just being pedantic
really since the compiler probably just does the right thing here.
model: don't automatically generate patch/fin meshes

Since we only need patch/fin geometry when using the hair component this
updates the model code so we have a rut_model_new_for_hair() api that
can be used to derive a model from a previous model that is suitable for
hair rendering. This way we can make rig-engine.c trigger this code path
only when we adding a RutHair component to an entity.
patching: use bitmask for adjacency matrix

The adjacency matrix only needs to store a boolean for each entry so we
can massively reduce the amount of memory required by using a bitmask.
For more complex models the size of this matrix can a limiting factor.
model: review what texture coords we generate

It turned out that tex_coords1/4/7 were always just a copy of
tex_coords0 so instead of actually duplicating the data this instead
makes those attributes share the tex_coords0 data.

Correspondingly this reduces the size of the Vertex struct used for
generating patch geometry which now only maintains two sets of tex
coords - the base image source coordinates and the generated patch/fin
texture coordinates. This also updates extract_texture_coordinates to
only extract patch coordinates and not to overwrite the base image
source coordinates.
hair: optimize how we track shells/particles

This replaces the use of GQueues with GArrays instead. In glib GQueues
are implemented as a linked list and the pop/push pattern being used to
iterate the queues will internally be unlinking/linking the item from
the list and freeing/allocating link nodes each time which isn't ideal
for repeated iteration of this data.