Got basic triangle demo from http://www.open.gl/ working.
Fix error checking for fragmentShader compilation.
Made the triangle red.
Made color of triangle time-varying.
Changed triangle rendering to a color gradient across its three points.
Import a bunch of GL* types directly into the mod namespace.
Revise rendering to have level-of-indirection via element buffer.
Draw rectangle in naive manner (via six vertices instead of reusing four).
Render rectangle less naively via DrawElements.
Prep work for textures secton of tutorial: factor out initialization code.
Added initial open_gl_textures example code from tutorial.
Added code to mix together two textures.

Added option to open_gl_textures that dispatches between the different
texture handling.  As part of this, we conditionally construct
different source strings to hand off to the fragment shader, varying
how `outColor` is set.

There were some important details I had missed at first while trying
to develop this.  Perhaps most important: the second argument to
`gl::Uniform1i` is important; I was accidentally passing `0` to both
calls for a while there (rather than `0` and `1`).  The text at
http://open.gl/ does not really say much about what the significance
of the two values is in these cases: what does it mean to set a
`uniform sampler2D` to `0` or `1`?  I guess I will puzzle this out in
time.

Finally, removed old dead (if-false'd-out) code.
Refactoring: newtyped VertexArrayObj and VertexBufferObj with appropriate methods.
Refactoring: made newtyped ElementsBufferObj and bind_array method.
Refactoring: newtyped VertexShader with single `source` method.

If I can find a reason to split `source` into separate "source" and
"compile" methods then I can do so.

Abstraction is currently leaky since I expose the underlying gluint
for interfacing with AttachShader.  Will fix.
refactoring: newtyped FragmentShader with `source()` method.

Also has a `gluint()` method but that probably will not stay long.
Refactoring: extended ShaderProgram API to enable code cleanup.
Refactor: move newtypes to submod to isolate interior access.

This allows me to actually enforce abstraction boundaries (e.g. not
exposing the underlying gluint within a VertexShader or
FragmentShader).
Refactoring: two more newtypes, for AttribLocation and UniformLocation.

It would be nice to figure a HOAS-y way to make these safe, e.g. to
get some sort of guarantee that the identifiers I am talking about
actually correspond to something in the Shader program that we are
manipulating.  But for now this will do.

Anyway, the code is a little bit cleaner now.
Refactoring: Attempt to use ToArgs trait pattern for method overloading.

Next up: attempt to incorproate some amount of type level reflection
to clean this up some more.