Begin moving the node registry to the kernel from model/object.

The kernel has been delegating knowledge of the node graph and node
change flags to the model/object driver. But this doesn't work well
since model/object isn't normally notified about changes to a node until
after the other drivers. Extra calls into model/object are in place so
that preceding drivers can ask about a node's ancestors or prototypes in
creatingNode, for example, but this is an abuse of the driver API.

Tracking changes in model/object also requires extra work since
model/object doesn't see changes to properties handled by other drivers.
Change flags may not be set in some cases, which can cause replication
errors.

The kernel will be better off if it manages this data itself. With a
local registry, it will be easier for the kernel to register a new node
just before it is first exposed to any driver and unregister a deleted
node right after its last driver message.

This commit creates the node and per-node property registries, and
records per-node property change flags.

Fixes #1815.
Only record changed properties in `getState`.

Previously, after any property changed on a patchable node, `getNode`
(which feeds `getState`) would include all of the node's properties in
the patch. Now, only the properties that actually changed are included.

Fixes #2236.
Track kernel re-entry originating with aggregate property sets and gets.

Set the markers so that if `kernel.setProperties` or
`kernel.getProperties` set or get a property having an accessor function
that refers back to the property, or if a driver calls back to the
kernel to refer to the property, `setProperty` or `getProperty` will
start the action with the correct driver.

Previously, only actions originating with `setProperty` or `getProperty`
were tracked this way. This commit adds tracking for actions originating
in `setProperties` and `getProperties` as well.
Allow descriptors to declare properties without assigning a value.

`kernel.createProperty( nodeID, name, undefined )` will create a new
property without assigning an initial value. This can be useful if the
property should have the value `undefined` or if a driver binds the node
to an internal object that already has a value (such as `transform` in a
Collada object).

But since YAML and JSON have no representation for `undefined`, there
has been no way to do the same thing using a component descriptor.

This commit extends the detailed initializer format slightly to allow an
`undefined` value to be explicitly declared:

    properties:
	  alpha:
	    "alpha"
	  beta:
	    value: "beta"
	  gamma:
	    undefined: true

`alpha` is created with the value `"alpha"` using a simple initializer.
`beta` is created with the value `"beta"` using a detailed initializer.
And `gamma` is created using a detailed initializer with the initial
value undefined.
Detect delegation during property assignments.

When a property assignment is executing, execution should stop once the
property is assigned. If the kernel is configured with drivers A and B,
for example, the kernel shouldn't call B if A handles the assignment.

The existing implmentation only does this correctly when a property
accepts the assignment directly or when it delegates to itself (such as
with `set: this.name = parseInt( value )`). If the assignment delegates
to another property, this isn't considered assignment, and execution on
the initiating property continues with the remaining drivers.

This causes extra work when invoking drivers lower in the stack for
properties that have already been delegated, change flags to be set on
nodes that haven't actually changed (for example n, in the case of n.p
=> m.q), and properties delegating to other propertes to be incorrectly
included in change sets (for example p in the case of n.p => n.q).

This commit detects delegation to other properties by watching for other
assignments made while executing `setProperty`. When delegation is
detected, execution completes just as it would if a driver accepted an
assignment directly.

Also, lots of tests.

Closes #1635.
Add tests to ensure "gets" and "sets" take proper path through drivers

fixes #2563
Fix typo in test comment

refs #2627
Remove erroneous conditions that cause satProperty when it should not occur
Modify getProperty to pass tests

refs #2593
Remove unused getPropertyValues function
Guard against cases when satProperty is called without an initializeProperty

The current implementation of property delegation allows an initializeProperty event to be skipped for properties that delegate.
refs #2593
Fire satProperty event with the internal value
when setProperty is called during replication.

refs #2593
Fix copy-paste error in getProperty

refs #2593
Fire gotProperty event during replication when appropriate

refs #2593
Add documentation for the update of how property delegation behaves

If a property setter transforms a property in a setter, satProperty is fired w/ the transformed value, not the original value
Add comment to commented-out patches object to explain why it's commented out

refs #2593
Mark commented-out section of kernel node storage (methods and events) as TODO

refs #2593
Update tests to only expect inner properties to send satProperty event.

refs #2593
Make satProperty only fire in an entry to setProperty if property was assigned

refs #2593
Removed inappropriate markup from node documentation and cleaned up documentation

refs #2593