Update branch 'feature/models-and-surrogates' to latest 'feature/puck-dynamics'

Also insisted that README.md's build status line references “feature/models-and-surrogates”.
Switched Tests to use .-based accessors

Switched InchCoordProxyTests and InchLocationTests from using getter and setter methods to the dot-notation setters and getters.  The “#pragma clang diagnostic ignore” lines that were recently added to each model's P001ModelSurrogate category make this possible without any warnings or errors.

Note: This turns the mistake that we've been calling setters on surrogates for a while now (which are by nature readonly) into a hard error.  Which is good, but bad. YKWIM

Minor:
• Moved object sets in InchLocationTests#testXYSurrogation to inside the brackets, matching InchCoordProxyTests's format.
• Switched `P001ModelSurrogate<…ish>` syntax to now-preferred `id<…ish>`
Replaced P001ModelSurrogate's @dynamic decls with #pragma

Replaced P001ModelSurrogate's @dynamic declarations for the “invalid” and “unset” properties with a `#pragma clang diagnostic ignored "-Wobjc-protocol-property-synthesis"` @implementation prefix and a `#pragma clang diagnostic ignored "-Wobjc-missing-property-synthesis"` @interface wrap.
Surrogate usage fixes for tests

These together should fix the build.

• In InchCoordProxyTests, using model to set properties instead of the surrogate since sets on surrogates are no longer kosher.
	» I still haven't fully decided on whether surrogates should always be read-only or not.  I suppose if I find myself coded into a corner, I'll reverse this decision.  We'll see…
• Added `InchCoord *x` and `InchCoord *y` overrides (of `id<InchCoordish> x` and `id<InchCoordish> y`) to InchLocation to allow `location.x.doubleValue = secondLocationX` set to work properly.
• Added to P001ModelSurrogate explicit `isInvalid` and `isUnset` accessors (otherwise they're automatically synthesized with associated BOOL ivars, which start at `NO` and never change value).  Also set up `_cachedIsInvalid` and `_cachedIsUnset` in the same manner as `_cachedHash`.
	» It seems this implementation isn't going to scale well to potentially many flags and/or model-specific flags.  I suspect I'll have to do something about making a objectified state facility soon.
	• Removed the `#pragma clang diagnotic`s surrounding P001ModelSurrogate's interface and implementation.  Their warning was a “true positive”.

Also:
• A bit more documentation on P001ModelSurrogate's `_cachedProperties`, `_cachedHash`, `_cachedIsInvalid`, and `_cachedIsUnset` ivars.
Cleaned up test structure and messages

• Broke down each test into bracketed steps, each prefixed by the constants it uses (that are sometimes referenced later on) and the name of the step in the form of a NSString set to a new `test_step` ivar.
	• All assert messages now start with “After %@” with “%@” filled in with the `test_step`.  The “at this point” suffixes eliminated.
• Some of the assert messages improved to “_underline_” the most critical part of the message (namely, an easily-confusable state descriptor).
• All assert messages are now sentence-case and end with a period, which should make them stand out better.
• `P001ModelSurrogate` instances are now allocated to autorelease (which happens at the end of the test because SenTest has every test invoke wrapped in `[[NSAutoreleasePool alloc] init]` and `[pool release]`.
Added InchCoordProxyTests#testProxyValidityFlagPersistence

• New `testProxyValidityFlagPersistence` test that starts similarly to `testInstanceAndProxyValidityFlags` but instead of setting a value (and thus validating the inchCoord/Proxy) it immediately releases the `inchCoord` and test that the `inchCoordProxy` has the correct flags.
	» This test is essentially an alternate version of `testInstanceAndProxyValidityFlags` where `inchCoord.doubleValue` never gets set.
• Added step to `testInstanceAndProxyValidityFlags` that test `inchCoordProxy`'s flags after `inchCoord` has been released (to match `testProxyValidityFlagPersistence`).

Minor:
• Updated function comment for `testInstanceAndProxyValidityFlags` and added a similar one to `testProxyValidityFlagPersistence`.
Renamed ObjcRuntimeUtils functions

Renamed the functions in ObjcRuntimeUtils to more closely match the naming in <objc/runtime.h>, like they're a natural extension of the runtime API.  Updated all project usages to the new names.

Also Rearranged ObjcRuntimeUtils.m a bit to more closely match the order of the header file and eliminate unnecessary forward declarations.
Minor: `invalid` and `unset` doc-comments

Updated P001Modelish and P001ModelSurrogate's doc-comments for the `invalid` and `unset` properties to just a `@see` reference to the associated P001Model property (since that's where the state data is ultimately coming from).
Broke down Surrogate caching code a bit further

• First, renamed P001ModelSurrogate's caching methods to more appropriately have “Object” in their names instead of “Value”.
	» Now: `cacheObjectForInstance:property:`, `objectForInstance:property:`, and (a new) `objectForInstance:propertyName:`
• Broke down objectForInstance:property:'s core functionality into a new objectForInstance:propertyName: method, intended for potential reuse in the invocation handling.
Added to the P-001 Test target all of the standard frameworks that the P-001.G-imr target uses

CoreGraphics, QuartzCore, GLKit, and OpenGLES frameworks added to P-001 Test target (not libPods.a, at least not yet).
InchLocation returns NAN-CGPoint when invalid

When invalid, models should return crazy non-confusable and (if possible) non-usable values, not normalish values (which zero is).

Now when invalid, InchLocation now returns for cgPointValue a `kNANPoint`, which is initialized to a CGPoint with `NAN` for both X and Y.
Models always return surrogates/readonly values for properties

Alright, it's final.  Models need to always return surrogates for their properties in order to ensure state integrity (especially cross-property) and proper ownership.  And where non-modelish types are returns (raw data), they need to be readonly like a surrogate.

In whole, all manipulation should be through modifier methods specific to the nature of the model.  Direct access to modify data only leads to treating the model as the data type, not the intent and purpose.

• InchCoord's doubleValue property and InchLocation's cgPointValue accessor made readonly (matching InchCoordish, but restated for clarity).
	• InchCoord's nsValue accessor added in the same manner, for clarity.
	• Removed “‘readonly’ because it's ours, not yours” comment on InchCoord#nsValue; it's no longer relevant.
• InchLocation's x and y properties changed to type `id<InchCoordish>`, matching InchLocationish and the current implementations, which return surrogates (also restated for clarity).
• InchLocation's cgPointValue property removed, leaving the readonly variant defined in InchLocationish
• Removed InchCoord#setDoubleValue: and InchLocation#setCgPointValue: implementations

Note: Currently the test build is failing due to inability to set property values directly, when previously it was allowed.
Minor: `self.invalid` in InchCoord and InchLocation

Previously in InchCoord and InchLocation's getters, I was using
Minor: Consistency of `self.invalid` in InchCoord/Location

InchCoord and InchLocation previously used `_unset` or `self.isInvalid` (weird) to check the object's state in getters.  Now they both consistently use `self.invalid`.

Also added a comment to InchCoord's `_doubleValue` property to make it clear that it should be NAN whenever the InchCoord is invalid (as opposed to specifying a custom accessor for doubleValue that has to do an extra check at time of get).
Minor: Suffixed InchLocation's `_x` and `_y` ivars with `Model`

Renamed InchLocation's `_x` ivar to `_yModel` and `_y` ivar to `_xModel` in order to confuse the fuck out of everyone…

	Just kidding!  `_x` _actually became `_xModel` and `_y` became `_yModel`.  Rationale is to draw a stronger distinction between “x” as a property (which could returns as a surrogate) and the actual stored “x model” (and likewise for “y”).
Minor: Cleaned up InchCoord/Location headers

• Removed blank lines from InchCoordish and InchLocationish protocols in order to make them more compact.
• Moved the doc comment for nsValue from InchCoordish to InchCoord.
	» We the main model class to be authoritative.
• Added nice, clean Apple-doc-style section headers “Property Access”, “Convenience Access”, and “Explicit Manipulation” to InchCoord's and InchLocation's interfaces for, respectively, the “true” properties, the NS/CG convenience getters, and the manipulateAs…: methods.
Added ObjcRuntimeUtils.m to Tests target

I thought this was added before, and it only seems to squeel when making a device build.  Strange.
Minor: Cleaned up P001ModelSurrogate's init

Rearranged things a bit such that the assignment from the arg to the _instance ivar happens first, then everything else uses the ivar.
P001ModelSurrogate forwardInvocation: refactoring

• `forwardInvocation:`'s logic broken into new `usingInstanceHandleInvocation:` and `usingCacheHandleInvocation:` methods.
	» The logic between these two is quite a bit different (despite following a similar form) and although they could be combined into one scope with a bunch of period if/elses, I feel a number of helper methods is the smarter DRY approach, and this should lead there.
	• Some clean-up and optimizations along the way as well.
• Minor: `modelWillDie:` now sets the _instance ivar to nil, for sanity's sake.
P001ModelSurrogate property caching fixes