Cleaned up old GL code.

Removed commented-out stuff:
• GLKView calls glViewport for us before every frame; we don't need to touch it.
• glScissor is unnecessary; the default is effectively the entire viewport.
• Retina half-scale modelviewMatrix call.  Don't need it (yet).
• Direct glMatrixMode/glLoadIdentity/glOrtho/glScale setup calls.  Handled by the GLKBaseEffect transform set.
• light0 calls.  No lighting here.
• Push/PopMatrix stuff.
• Extra unnecessary prepareToDraw calls.
• glColor4f calls.
• A lot left-over vertex stuff in setUpGL.
• A lot left-over vertex stuff in glkView:drawInRect:.

Clean-up:
• Moved prepareToDraw to the end of setUpGL.
UIColor extension w/ UIColorValues and accessors

Created UIColor+SDTAdditions with:
• UIColorValues struct, a pure-data storage type for HSBA, RGBA, or WA (white/alpha) color values.
• get…Values accessors methods for HSBA, RGBA, and WA.

Added to project and prefix file.
Now nearly matching the CoreGraphics version.

It's surprisingly fast (60 FPS with plenty of head room) even though it's drawing quite a few polys (256 slices for some of the bigger circles) and is unnecessarily repetitive (reloading vertex data onto the card on every draw).  Performance oddly drags on the iOS Simulator though.

After some clean-up, minor fixes, and addition of missing border (and _maybe_ that BG texture), we should be able to call this refactor complete.  It is a bit sloppy and repetitive right now (intentionally to an extent, in order to properly understand what we need where before wrapping up in models).

Bringing SceneViewControllerForGLK and SceneForGLK up to speed:
• UIResponder touch-handling methods (touchesBegan:withEvent:, touchesMoved:withEvent:, touchesEnded:withEvent:, touchesCancelled:withEvent:) and state vars (_startTouchPosition and _prevTouchPosition) copied to SceneViewControllerForGLK from SceneViewControllerForCG.
	» These should also probably be in SceneViewControllerUtil.  I'm starting to really loathe this disjoint inheritance.
• SceneForGLK#drawContentLayerWithin:forView: fleshed out with focus-shifting transformation code (and arena draw call), akin to SceneForCG's equivalent.
	• Minor clean-up in SceneForCG#drawContentLayerWithin:forView: of renaming `theViewFocus_px` to just `viewFocus_px`.

VisRep GL drawing:
• Added glDrawUsing: to all the VisReps (Arena, Background, InsideRing, OutsideRing, and Ring).
	• ArenaVisRep#glDrawUsing: has call-outs to the other VisReps, like cgDrawWithin: (but with modelview resets before each).
	• BackgroundVisRep#glDrawUsing fills, but does not apply the texture (yet, or maybe not ever since the style may be changing soon).
	• InsideRingVisRep#glDrawUsing & OutsideRingVisRep#glDrawUsing fill their circles, but do not border them (yet).
	• OutsideRingVisRep#glDrawUsing 
• Renamed ArenaVisRep#drawWithin: to cgDrawWithin:.  I'm not sure how I missed this.
• Added lazy-init static-indefinitely-stored accessors using MemoizedVarInitializerForVerticeData to do the math and create the vertices, akin to the existing accessors for BezierPaths.
	» Still a lot of repeated code between classes (VerticeData struct, vertex calculation code, maybe some other stuff).  Ugg.
	• These methods are all (currently) copies or minor modifications of the circle and ring calculation methods createCircleVertices: and createRingVertices:hole: in SceneForGLK.
• static consts set up in each class for repeated stuff like sliceCount and oversizeRatio.

Overall clean-up and refactorings:
• `VerticeData` struct changed to more-common `_VerticeData` naming with typedef to `VerticeData`.
• `assemblyMode` GLenum added to VerticeData, intended for the glDrawArrays mode arg (GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP, etc.).
• Using UIColorValues4 and accessors to simplify the process of color-grabbing for `baseEffect.constantColor`.
• Caching GLKBaseEffect in a baseEffect local var where repeatedly used.  Not sure why I wasn't doing this.
• Switched to a model of storing the modelview matrix outside of the draw method and restoring afterwards, rather than saving and restoring inside the draw method.
	» Although this is against the typical clean-up-after-yourself approach, it bit me hard once already when I missed a closing restore.  This way is much safer and saner.
	» Unfortunately, this may be a little less performant, since the restore happens regardless of changes to the matrix.  However, GLKBaseEffect may be making this negligible by only talking to GL with the end-result matrices in the call to prepareToDraw (this is likely the intent.)
	» Discovered this methodology via Apple docs/code, I believe.
• Switched naming from using `ModelviewMatrix` (such as `saveModelviewMatrix`) to just `Modelview` (`savedModelview`), or in some tightly-scoped instances just `modelview`.
	» It's easier, and AFAICDetermine it's non-ambiguous.
Rotated the calculation for each ring by half-a-slice

This makes the circles look just a little nicer near the pixel-aligned edges (top, right, bottom, left) at a minor cost of a little more roughness at the 45°-aligned edges (TR, BR, BL, TL).

As a result:
• Removed simple calculations for ring top-inner and top-outer and circle top-point (leaving center-point as-is), as the first couple of points also need trig now.
• Slice-calc loops now start `sliceI` at -1 instead of 0, so that we calculate those first points (I know, weird math).
• And of course, half the slice's angular delta subtracted as a part of each point's angle calculation.