Moved binding destruction into its own method that gets called on Object#destroy.
Fixed a bug where calling tupleForPropertyPath with no path would throw an error.
Improved binding self-destruction for improved garbage collection in complex binding scenarios.
Added proper documentation for Binding#destroy.
Added several unit tests for binding destruction.
Added unit test for SC.tupleForPropertyPath(null).
Created destroyObservable to parallel initObservable; included TODOs for destroying observers and properties.
Uncommented one unfairly-maligned unit test.
Removes unused internal property of SC.Binding:_changePending.  This property gets assigned and never read other than in some unit tests which have been upgraded to check for the real indication of when a change is pending.
Adds test to show that reconnecting a binding updates the value again after the binding was disconnected.
Removes whitespace and tidies up some comments.
Fixes small memory leak in SC.ObserverSet.

Each time that a new observer is added to an object the ObserverSet for the object will add a tracking hash for the target and the method.  As more methods are tracked for the target, they are added and as methods are no longer tracked for the target, they are removed.  However, even when no methods are tracked for the target, the tracking hash for the target still exists.  This creates a small leak of memory, because the target may have been destroyed and freed, but we are still maintaining an empty tracking hash for it.

Here's an example that would create 3,000 empty hashes in coreOb._kvo_observers_key._members:

    obs = [];
    window.coreOb = SC.Object.create({ key: '1' });
    SC.run(function() {
      for (var i = 2999; i >= 0; i--) {
        obs.push(SC.Object.create({ myKeyBinding: SC.Binding.from('coreOb.key') }));
      }
    });

    SC.run(function() {
      for (var i = obs.length - 1; i >= 0; i--) {
        obs.pop().destroy();
      }
    });
Fixes memory leak in SC.Set.

The way that SC.Set removes objects is to "untrack" the internal index of the object by shrinking its length, but it never actually removed the object at the last index.  The only way that the object could be freed is if a new object is inserted at the same internal index, thus replacing it.  If the objects were removed in the reverse order that they were added, every object would still be in the set (until they were possibly overwritten).
Removes excess whitespace.
Extends SC.Observable:destroyObservable to also remove observers.

- Previously the object would remain registered in other object's ObserverSets and could not be freed.
- Adds tests for destroyObservable behavior.
Tidies up the SC.Binding destroy method and extends the tests a bit.
Implicit globals, creating a possible memory leak. Not sure if these were in fact cause a problem but as I was looking to extend this class those jumped out at me.
Merge pull request #864 from mitchless/menu-memory-leak

Fix implicitly defined globals in SC.MenuPane
Added special getter for "elapsed" time.
Created "%E" and "%e" time formatters, for elapsed time measurments.