Stop running `default` by default when an variant was indicated.
Some init work porting examples from GLSL Cookbook.

Found case where you want to separate Program creation from Program
linking: calls to glBindAttribLocation need to precede the link step.
Ported remainder of "Sending data to a shader using per-vertex attributes ..." example.

This gets us to a semi-short example that actually draws a
multicolored triangle in the window.
Some refactoring: Make it easy to use vertex_attrib_pointer when arrays are trivially packed.

(Better still could be to support having the AttribLocation carry its
type and not passing an argument at all, or passing a phantom struct
`Packed` and figure the rest out from the type attached to the attrib
location.)
Fix long-standing bug in my demo: Need to clear the background.

Fix long-standing bug in my demo: Need to clear the background, or
else arbitrary other graphics data can leak through.
Add `glsl::Packed` variant of `VertexAttribPointerRTTI`.

To further ease calls to `vertex_attrib_pointer`, make
`AttribLocation` carry the type of the value in the location, and then
enable one to indicate that the data-source that it is drawing from is
just a packed-array of such data.

Supporting this requires a little bit of acrobatics to allow the
`VertexAttribPointerRTTI` trait to actually make use of that location
type information when necessary (that's what the new type parameter on
`VertexAttribPointerRTTI` is for).

If I were really smart (and/or if Rust's type system were a bit more
expressive) I would also make the implementation of the `(&'a TUPLE,
&'a ROW_TYPE)` enforce that you only use compatible types such that
`TUPLE` can be assigned to `T`.  But that's okay, I can live without
that.
Cleanup: wrap `def_main` around `def_fn` to simplify very common case.
Cleanup: glEnableVertexAttribArray is not about current state.

It just flags that the attrib location will be accessed for rendering.

(I might try to fold this into the constructor for AttribLocation, if
I can figure out how to make the types indicate such usage.)
Make the binding of the fragment shader output explicit.
Demo usage of `layout (location = <n>)` qualifier.

This is a way to encode the attrib location directly in glsl rather
than by calling `glBindAttribLocation`.  (It is currently more verbose
in my code but I might put in ways to work around that, such as a new
variant of `fn global` that returns both a `Global` and an
`AttribLocation`.
Further example of using `layout (location = ...)`, here in Fragment Shader.
Removed some unused bindings.
Refactor: separate pre-link and post-link Program.

Introduces `ProgramBuilder` abstraction.  Note that the `link` method
takes self by value, to ensure that you consume a builder when you
create the linked `Program`.

(Why: According to my understanding, you could reuse the input text to
a Shader many times, and reuse a compiled Shader in many programs, but
you cannot, AFAIK, relink a program after it has been linked; I should
double-check that claim though).
Ported recipe for getting list of active attributes and their indices.

As part of this, separated out low-level non-type-tracking
`raw_attrib_location` method from higher-level type-aware
`attrib_location` method.
Ported example of sending data to a shader using uniform variables.

This makes the triangle rotate in place.  (Which I did in an earlier
example, which is why I cut-and-pasted the code for constructing the
rotation matrix here, since I do not have a port of GLM to Rust.)
Code cleanup: remove some unused variable bindings.

Drive-by cleanup: revise my for loop to use `ref` in destructuring
bind (rather than tuple `ref` methods).