Texture2D lib

Added the old Texture2D class (version 1.8) from the old (pulled) CrashLanding Apple sample code (via https://github.com/mpatric/texture-ext).  Added to project file as well.

The CrashLanding demo was known to have issues with its SoundEngine code (and was outdated in general), but this texture class should work fine.  It does need to be updated for GLES 2 though.
Standardized code style of Texture2D

• Doc comments changed to `///` format (except the file header doc comments, which were changed to `//`).  `@` prefix added to existing content prefixes.  `**…**` and `_…_` Markdown-style wrappers used instead of all-caps yelling.
• Intra-line tabs and multiple intra-line spaces replaced with single spaces (except for tabs holding indentation, of course).
• Spaces after control structures.
• No spaces after Obj-C method return types.
• `#define` constant changed to `static const`.
• Double statement-end semicolons singularified.
• Blank line spacing touched up all over (single within methods, double between distinct larger things, triple between largest document-sectional things).
• Removed unnecessary parentheses that were hurting understandability rather than helping it (double parentheses, and a quite a few simple conditionals where operator precedence is easy and well-known).
	• And admittingly, parentheses added to a couple of spots for clarity (ternary ifs, and initialization lines previously using tab spacing for clarity).
• Spaces between the type and pointer star, not after.
	» This choice is derived from the fact that the `*` is not directly part of the type; it's more of a type modifier.  That is, `int *test1, test2;` makes `test1` into a pointer and `test2` into an int.
	» The choice not to put spaces on both sides of the `*` is to differentiate from uses as the multiplication operator (where we always place spaces on both sides).
• Other minor line break and spacing stuff.
Standardized spacing

Fixed some spacing differences that I discovered when cleaning up the Apple Texture2D sample code.

• Comments always follow the last slash with a space, then optionally tabs (to differentiate from commented-out code which never has a space following the slash).
	» Found via a regexp serach for `^.+(?<!// )(?<!\t)\t`
• No spaces after Obj-C method return types.
	» Found via `^([-+] \([^\)]+\)) `
• Spaces between the type and pointer star, not after.
	» This choice is derived from the fact that the `*` is not directly part of the type; it's more of a type modifier.  That is, `int *test1, test2;` makes `test1` into a pointer and `test2` into an int.
	» The choice not to put spaces on both sides of the `*` is to differentiate from uses as the multiplication operator (where we always place spaces on both sides).
• Tabs for indentation!!!
	» Crazy, I know.
Fixes for the Texture2D class

• Fixed a format warning on the description stringWithFormat: call.
• Added errors and “data release, return”s for spots where a created context could fail.
• Changed initWithString:dimensions:alignment:fontName:fontSize: to initWithString:dimensions:alignment:font: because it makes more sense this way.
• Multiplying by 0.5 rather than dividing by 2, because it's more efficient for the processor.
SceneForGLK is now drawing pixel-matching text.

SceneForGLK is now rendering text (prototypeName, for now) with CoreGraphics and showing it on a texture in a manner that matches the SceneForCG implementation pixel-for-pixel.  Code borrows from the technique used in Texture2D, but doesn't use the Texture2D class directly.

How is this possible, you ask?

• drawOverlayLayerWithin:forView: now sets up screen coordinates (Y-flipped of what the glViewport is) and resets the modelviewMatrix to that before each draw sub-method.
• drawPrototypeNameOnLine:within:forView: fleshed out with:
	• text determination, inset calculation, and string drawing matching SceneCG's
	• creation of an alpha CGBitmapContext
	• translating and scaling the CGBitmapContext for drawing
	• saving the CGBitmapContext into a CGImage and loading that into a GLKTextureInfo
	• 2-tri (a rectangle) textured poly coord and uv calculation (into a AGLKVertexAttribArrayBuffer), taking into account texel-to-pixel alignment mathagic
	• setup of the baseEffect for texture drawing, with help from `GLKEffectPropertyTexture (AGLKAdditions)`
'	• and finally drawing of the text texture
• TexturedVertexCoords struct and TexturedVertexCoordsMake function to create and store 3-D positional and 2-D vertex UV data interleaved (the way GL likes it).

As a result, updated elsewhere:
• In SceneForCG, added insetSize local vars for making the draw code easier to read.
• SceneViewController#setUpGL now disables texture2d0/1; they are enabled by default, I recently discovered.

Also:
• Removed no-longer-used include of SceneUtil in SceneForCG.
• Moved sClearingColor, sCircleFillColor, and sCircleEdgeColor up to global static vars rather than hidden function-scope statics (like the UIColors pseudo-constants elsewhere).
• drawViewFocusCoordsOnLine:within: given a forView: part, just like the rest of the draw methods.
Texture2D removed

Texture2D was written for OpenGL ES 1, and would be too difficult to update for 2 given that I only need a tiny portion of it which has now been recreated in SceneForGLK.  Removing until needed again.
Fixed build issues with debugging code in VerticeData.m

• SDTLog changed to SDTLogInFunction calls with manual extra data, since SDTLog requires being inside of an Ojective-C class method (not just a C function).
• Include added for `GLKit/GLKMathUtils.h` for NSStringFromGLKVector3().

Also:
• SDTLog branched to SDTLogInMethod and SDTLogInFunction, the former aliased to SDTLog.
Added low-poly-xyz-axes model

• .blend original Blender 3D source file
• .obj and .mtl Blender export as Wavefront
• .fbx Blender export as Autodesk FBX
• .dae Blender export as Collada
• .h file, converted from .obj file using obj2opengl.pl

Added all to project file, but none added to target memberships (except the .h file, implicitly).

Also added obj2opengl.pl script to a `Tools/` dir, from https://github.com/HBehrens/obj2opengl.
Fixed low-poly-xyz-axes and moved data to low-poly-xyz-axes.c

• Fixed the constants generated by the stupid obj2opengl.pl script to actual C constants: `low-poly-xyz-axesVerts` to `kLowPolyXyzAxesVerts` and `low-poly-xyz-axesNumVerts` to `kLowPolyXyzAxesNumVerts`.
• Changed both to `extern`s and `const`s, and moved their data definitions to a new low-poly-xyz-axes.c file.
• Added output of obj2opengl.pl (with useful center and scale info) as a header comment for low-poly-xyz-axes.c.
DebugAxes set up

X and Y debug axes set up and drawing for CG and GL, and as a PPI unit for the “content layer” and at screen-size for the “overlay layer”.

Added to project file as well.
Merge branch 'refactor/re-gl-ize' into debug/refactor/re-gl-ize

Resolved conflicts within:
	App/SceneForCG.m
	App/SceneForGLK.m
Lightened debug axis colors a tad.
Fixed coordinate systems

Fixed the handling of coordinate systems, especially proper Y-flip-or-not-to-flipping.

• The default coordinates are now device points with Y0 starting at the bottom (Y+ visually upward, matching the GLK default), the same but with Y0 at the top for the overlay layer (Y+ visually downward, matching UIKit/Quartz), and Y+ upward with the origin shifting for the content layer.
	• CGAffineTransform and CTM manipulations added to SceneForCG in drawOverlayLayerWithin:forView: and view:drawInRect: to orient things properly (Y-flipping).
	• GLKMatrix and modelview manipulations added to SceneForGLK in drawOverlayLayerWithin:forView: and drawContentLayerWithin:forView: to orient things properly (Y-flipping).
		• Content layer viewFocus Y-flip hack removed as a result.
• Scene#shiftFocusBy: replaced by shiftFocusByScreenPx:, shiftFocusByScenePx:, and shiftFocusBySceneIn:, to differentiate shifting by screen coordinates, GL scene coordinates, and GL scene coordinates within the pixels-to-inches transformation.
	• Also, viewFocus_px has been renamed to viewFocus_pt to match Apple's usage of the terms pixels (literal pixels) vs. points (retina-disregarded).  Related uses of `_px` updated to `_pt` as well.
• Scene now determines the PPI, and everything under the Scene (VisReps) use that.
	• Scene's screenPPIRetinaDisregarded and screenPPI accessors replaced with a definite PPI.
	• VisReps are now initialized with a `Scene *` rather than a PPI value, and use that weak reference to it to get the PPI when needed.  A bunch of the PPI setting and validating junk removed from the VisRep implementations as a result.
• Replaced BackgroundVisRep's inverse-current-CTM hack with shift based on the Scene's current viewFocus.
	• However, an issue remains that the BackgroundVisRep's pattern phase offset needs to be y-flipped (again, after all the other transformations).  I don't know why; perhaps pattern drawing ignores the CTM.

Minor:
• Some clarity comments here and there, especially regarding orientation.
• Tested an @todo regarding text overdraw; there are no issues, comment removed.
• Moved the screen-coord blue circle to 3/4 of the way down the screen— it's going away soon anyway.
• A couple of uses of drawRect replaced with viewSize (view.bounds.size).  I really need to make a full-pass and fix all of these— drawRect is for culling, not positioning.
• Some direct accesses of the _viewFocus_pt ivar replaced with proper getter calls.
Half-circle debug drawing.

On the top/Y+ half of circles are drawn, for debugging.

Polygonal half-circle is created by-hand for CG because the arc drawing wasn't orienting as expected; this ensures that Y+ is for sure Y+.

Note: A bit sloppy to help clean merges later; also, `(void)` casts to squelch unused var warnings.
Merge branch 'refactor/re-gl-ize' into debug/refactor/re-gl-ize