Installed CocoaPod for MAZeroingWeakRef

Intending to use this for a first pass at a smart proxy.
WIP InchCoordProxy implementation

• Takes an InchCoord instance with initWithInchCoord and creates a weak ref (MAZeroingWeakRef) to it.
• Has basic and placeholder message forwarding set up.
• Initial, incomplete implementation of property value caching.
Added basic unit tests for InchCoordProxy.

• Created P_001InchCoordProxyTests with basic setup/teardown of an InchCoord and InchCoordProxy.
• testCacheProperties method, calling cacheProperties in order to check property introspection functionality.
InchCoordProxy property caching, working

InchCoordProxy's property caching now working, albeit not being called or used yet.

• _propertyCache created and filled by cacheInstanceProperties (formerly cacheInstanceProperties), cacheValueForInstance:property:, and valueForInstance:property:.
	• Test updated to call cacheInstanceProperties instead.
• createEncodeTypeStrFromProperty and createEncodeTypeStrFromPropertyAttributes functions added, although they're currently unneeded.
• NSObject hash and isEqual: methods added, both forward to _instanceRef.
InchCoordProxy cleanup

• Moved createEncodeTypeStrFromProperty and createEncodeTypeStrFromPropertyAttributes to an new ObjcRuntimeUtils.h/.m support lib.
• Removed attribute NSLogging.
Improved ObjcRuntime Utils and added test

• Renamed “createEncodeTypeFromProperty…” functions to “copyEncodeTypeFromProperty…” to match Obj-C library naming.
• Added getEncodeTypeFromPropertyAttributeList() function, which uses the safer and more-flexible property_copyAttributeList() API.
	• Switched copyEncodeTypeFromProperty() over to use getEncodeTypeFromPropertyAttributeList().
• Added testCopyEncodeTypeFromProperty test, to kind of test both InchCoordProxy and the ObjcRuntimeUtils that were written for it.
Removed copyEncodeTypeFromPropertyAttributes()

I'm fairly confident at this point that copyEncodeTypeFromProperty() and getEncodeTypeFromPropertyAttributeList() will serve all our needs and our own string parsing in copyEncodeTypeFromPropertyAttributes() isn't necessary.  Therefore:
• Removed copyEncodeTypeFromPropertyAttributes().
• Wrapped up property_copyAttributeList functionality into an internal copyEncodeTypeViaPropertysAttributeList() function.
• Removed extra checks from testCopyEncodeTypeFromProperty.
Additional `get…FromProperty/AttributeList()` functions

Now taking heavy advantage of the flexibility allowed by `getPropertyAttributeByCodeFromPropertyAttributeList()` _(previously `getEncodeTypeFromPropertyAttributeList()`)_ to be able to grab any property attribute's value.

• new internal generalized `getPropertyAttributeByCodeFromPropertyAttributeList()` function with the ability to grab any property by its code (replacing the existing `getEncodeTypeFromPropertyAttributeList()` implementation)
	• `getEncodeTypeFromPropertyAttributeList()` now uses `getPropertyAttributeByCodeFromPropertyAttributeList()`
	• new `getGetterNameFromPropertyAttributeList()`, `getSetterNameFromPropertyAttributeList()`, and `getInstanceVarNameFromPropertyAttributeList()` functions, all using `getPropertyAttributeByCodeFromPropertyAttributeList()`
• new internal generalized `copyPropertyAttributeByCodeFromPropertysAttributeList()` function, also grabbing by code and using `getPropertyAttributeByCodeFromPropertyAttributeList()` (replacing `copyEncodeTypeViaPropertysAttributeList()`)
	• `copyEncodeTypeFromProperty()` now uses `copyPropertyAttributeByCodeFromPropertysAttributeList()`
	• New `copyGetterNameFromProperty()`, `copySetterNameFromProperty()`, and `copyInstanceVarNameFromProperty()` functions, all using `copyPropertyAttributeByCodeFromPropertysAttributeList()`
• internal PropertyAttributeInfo struct with static consts for EncodeType, GetterName, SetterName, and InstanceVarName
Added new InchCoord/Proxy tests

Added new tests:
• testInstanceAndProxyValidityFlags, which tests that isInvalid and isUnset report the correct states in the InchCoord and its Proxy
• testProxyPropertyPersistence, which tests that the doubleValue set for an InchCoord is reported back properly, propagates to the its Proxy properly, and persists in its Proxy after the InchCoord is gone
	» currently failing, due to “-[MAZeroingWeakRef isInvalid]: unrecognized selector sent to instance 0x72ae9e0”, and likewise for “-[MAZeroingWeakRef doubleValue]”

Note: Opted to use method call syntax over property call syntax so that undefined methods in the proxy will still build.
Fixed bug in copyPropertyAttributeByCodeFromPropertysAttributeList()

Previously, it would try to strcpy even when the source (propertyAttributeValue, formerly propertyEncodeType) was NULL.  Now it checks and returns NULL if the propertyAttributeValue resulting from getPropertyAttributeByCodeFromPropertyAttributeList() was NULL (i.e., no property attribute was found).

Also renamed function-scope variables from using “EncodeType” to “AttributeValue”.
Holy Shipley, it works

InchCoordProxy is now caching InchCoord's properties at time of death and reporting them back forevermore.  And all with delicious dynamism.

• InchCoord's dealloc posts an "InchCoordInstanceWillDie" notification before `[super dealloc]`-ing, giving InchCoordProxy a chance to observe the notification and fire its `instanceWillDie:`.
	• The MAZeroingWeakRef isn't needed here any more— we need to talk to the instance before its gone and are now doing just that.  `_instanceRef` removed in favor of just a weak assigned (and hand-nil'd) `_instance`.
• InchCoordProxy now tracks whether the instance is gone or not in an `_isInstanceDead` ivar.
	• New convenience property `readOnly`/`isReadOnly` reports just this.
• Properties are now stored by getter name, rather than property name, since we'll only be getting fetch requests by getter name _(we currently don't support KVC's `valueForKey:`)_.
• `forwardingTargetForSelector:`, `forwardInvocation:`, and `hash` given branching logic depending on whether the instance is still present or gone.  `forwardingTargetForSelector:` and `hash` are straight-forward, while `forwardInvocation:`…
	• `forwardInvocation:` now, when the instance is gone, copies the cached object pointer or NSValue-unwrapped value to the NSInvocation's returnValue, while performing a good number of checks to make sure the invocation is a getter, has a compatible return value type, etc.
	• `couldBeAGetterName()` and `couldBeAGetterMethodSignature()` helper functions added and both used for `forwardInvocation:`'s checks.
• `cacheValueForInstance:` is now copying the value into `_cachedProperties` under the custom getter name (if there is one) or the property name.

Other things that were fixed or improved along the way:
• InchCoord's property definitions copied to InchCoordProxy, and @dynamic declarations added in order to quell compiler warnings.  This is unfortunately the only non-dynamic part (dependent directly on InchCoord) of InchCoordProxy.
	» You'd think that NSProxy subclasses wouldn't be subject to this scrutiny since… it's a proxy.  C'est la vie.
• `_propertyCache` renamed to `_cachedProperties`.
• `_cachedHash` added as a cached version of the instance's `hash` value, and used to implement `isEqual:`.
• Added missing `free(propertyList)` in `cacheInstanceProperties`.
• Freeing the unused class_copyPropertyList return when sizing up for cacheValueForInstance:'s lazy init of NSMutableDictionary.
Generalization of InchCoordProxy to ObjectSurrogate

Throughout the implementation of InchCoordProxy, I've been hit over and over with the idea that most of this is non-specific any particular class, that it should be easily generalized to any work with any conforming class.  Likewise, I've been hit with the idea that `Proxy` is too vague of a term for this concept, and that terms like `Trampoline`s are used in the Obj-C community.

I finally settled on a dynamic class name of `ObjectSurrogate`, from Objective-C Runtime Programming Guide's Message Forwarding chapter's Surrogate Objects section, which defines it as such:

> Forwarding not only mimics multiple inheritance, it also makes it possible to develop lightweight objects that represent or “cover” more substantial objects. The surrogate stands in for the other object and funnels messages to it.

That sounds like it fits.

So here's what happened:
• InchCoordProxy became ObjectSurrogate, and `InchCoord` by name all over became just `Instance` and `InchCoord` by type became `NSObject`.
	• Added a surrogateWithInstance: convenience constructor.
• InchCoord-specific properties moved to an `InchCoordish` protocol, which both `InchCoord` and a new `ObjectSurrogate (InchCoord)` adhere to.
	• Likewise, InchLocation-specific properties moved to an `InchLocationish` protocol, with `InchLocation` and a new `ObjectSurrogate (InchLoacion)` adhering.
•  @dynamic declarations for InchCoord and InchLocation properties now in the respective `ObjectSurrogate (…)` categories.
• InchLocation now returns `id<InchCoordish>` objects for `x` and `y`, rather than literal `InchCoord *`s _(since they'll likely be `ObjectSurrogate`s most or all of the time)_.
	• Getter implementations replaced with ones that create autoreleased ObjectSurrogates.
• In InchLocation.h, `@class InchCoord;` forward declaration replaced with `#import "InchCoord.h"` (`@protocal InchCoordish` was initially tried).
	» _I don't even want to tell you how many weird errors the compiler pukes when it is told to follow a protocol but doesn't even know if the `id`-typed instance is an NSObject or an NSProxy.  Except I'm not sure if that was the culprit.  It just was fuked._
• InchLocation posts an `InstanceWillDie` notification (of the `InchCoordWillDie` fame) in its dealloc.
• New P_001InchLocationTests, which currently have one test, `testXYSurrogation`— which tests values and persistence of InchLocation's x and y properties, much like `testProxyPropertyPersistence`.
• P_001InchCoordProxyTests updated: `InchCoordProxy` to `ObjectSurrogate<InchCoordish>` mostly, and a few other change-overs.
Update branch 'feature/puck-dynamics' to latest 'master'

Also modified the Travis-CI build status image in the README.md to point to the feature/puck-dynamics branch rather than master.  This may be an exercise in futility, but if it does work without much extra effort (git rerere?) it could/may/will be awesome.
Update branch 'feature/models-and-surrogates' to latest 'feature/puck-dynamics'

Also replaced “feature/puck-dynamics” in README.md with “feature/models-and-surrogates”.
Update branch 'feature/puck-dynamics' to latest 'master'

Also replaced “master” in README.md's build status line with “feature/puck-dynamics”.
Update branch 'feature/models-and-surrogates' to latest 'feature/puck-dynamics'

Also replaced “feature/puck-dynamics” in README.md's build status line with “feature/models-and-surrogates”.
WIP P001Model superclass

So after putting together ObjectSurrogate (now P001ModelSurrogate) and seeing a lot of repeat code in InchCoord and InchLocation, it seemed to make sense to create a superclass that handles most of these model's routine responsibilities.

Scoping down ObjectSurrogate's (now P001ModelSurrogate) possible input data set to a more controlled one (rather than any NSObject) doesn't seem like a bad idea either.  Though standard/Foundation Obj-C would probably allow any class to join in as long as it adopted the right protocol (like NSCoding).  Maybe I'll extract the functionality off later in that fashion.

New P001Model abstract (by definition of having an incomplete implementation and refusing direct instantiation) base class:
• `invalid` and `unset` moved to P001Model from InchCoord and InchLocation
• `NSObject` references all over the place changed to type `P001Model`
• InstanceWillDie notification moved to P001Model's dealloc (also away from InchCoord and InchLocation)
	» However this requires the sub-classes to call `[super dealloc]` before releasing their properties, which is messy.  Need to find something better for this.
	• WIP implementation of setUpProperties and tearDownProperties methods to create and destroy properties for subclasses.  Also, a helper eachProperty: method.

ObjectSurrogate renamed to P001ModelSurrogate:
• `invalid` and `unset` defined in P001ModelSurrogate, since every P001Model will have them
• `_instance.hash` call changed to `[_instance hash]` (NSObject defines a method not a property, so this was causing compiler errors)
Subclass dealloc ModelWillDie swizzle-wrapping

P001Model subclasses' dealloc methods are now wrapped with an outer dealloc that posts a ModelWillDie notification before continuing on to the original dealloc.

In P001Model:
• Removed partially-implemented setUpProperties, tearDownProperties, eachProperty:.
• Moved `postNotificationName:@"InstanceWillDie"` from the dealloc to a `dealloc_withModelWillDie_IMP(id self, SEL _cmd)` function, which calls dealloc_withoutModelWillDie after posting the notification.
•  Created swizzleDeallocForModelWillDie and unswizzleDeallocForModelWillDie class methods: the former attempts to use swizzling to move dealloc's implementation to dealloc_withoutModelWillDie, and add the dealloc_withModelWillDie_IMP as both dealloc and dealloc_withModelWillDie; and the latter for reversing the changes.
	» Adding it in both places ensures we can alway get to the implementation we want without ambiguity.  This could be thought of as two differing implementations (`dealloc_withModelWillDie` and `dealloc_withoutModelWillDie`) and a `dealloc` alias to `dealloc_withModelWillDie`.
	» Both are safe to call multiple times; they store an association object boolean on the Class that reports if the swizzle has already been done or undone.
	• kModelWillDieSwizzleAssociationKey added, for tracking the association object added to the Class.

Other:
• P001ModelSurrogate updated to use `modelWillDie:` instead of `instanceWillDie:`.
• In P001ModelSurrogate's init, added a safety check and NSInvalidArgumentException if the instance passed in is nil.
• P_001InchCoordProxyTests: Basic testInstanceAndProxyInit test added, which creates both an InchCoord and a proxy and makes sure they didn't fail.
	» This allows other tests to be simpler; if they were to fail from a bad init, this test would too.
Added tests for model swizzling/unswizzling

• Added P_001P001ModelTests, which currently tests models' swizzleDeallocForModelWillDie and unswizzleDeallocForModelWillDie.
• Since we need clean model classes to test this on, created two single-file basic BOOL-valued models (both interface and implementation) and put them in `P_001P001ModelTestsModel.inc` and `P_001P001ModelTestsModelWithoutDealloc.inc`, both of which are included into `P_001P001ModelTests.m`.
	• P_001P001ModelTestsModelWithoutDealloc is just like P_001P001ModelTestsModel, but without specified `- (void)dealloc` method.
	• Added to project with no Xcode-specified target inclusion (to avoid warnings).
Less heavy-handed dealloc unswizzling

Decided that it's pointless to completely remove `dealloc_withModelWillDie` and `dealloc_withoutModelWillDie` in `P001Model#unswizzleDeallocForModelWillDie` when we really just need to alias `dealloc` back to the original implementation (`dealloc_withoutModelWillDie`'s).

• Removed the unswizzleDeallocForModelWillDie `class_replaceMethod`s that swapped the messageForwading implementation into `dealloc_withModelWillDie` and `dealloc_withoutModelWillDie`.
	• Removed messageForwardingImplementation fetching, and the stuff it needed: `#import <obj/message.h>`, `#ifdef DEBUG`s, and `_objc_msgForward` check.
• Changed swizzleDeallocForModelWillDie's `class_replaceMethod` calls for `dealloc_withoutModelWillDie` and `dealloc_withModelWillDie` to `class_addMethod` calls.
	» Now we don't care if the method already exists; if it does `class_addMethod just aborts (saving effort).