Handle primitive types `null` and `undefined`

Check for `null` and `undefined` and handle them the same as other
native primitive types. Previously `factory(null)` resulted in an error
thrown and `factory(undefined)` was handled the same as `factory()`.

Remove duplicate logic in `ImmutableObject.prototype.set` that also
happens in `factory()`.

Add tests to assert primitive values are not wrapped as they are already
immutable.
Freeze empty object

Call `Object.freeze()` on the empty object instance. Previously this
object could be mutated resulting in all objects being mutated (by way
of the prototype chain as the empty object is the root prototype for all
objects).
Missing semicolons
Fix bug with `unset()`

Add test for second case of `unset()` where the property being removed
is in the prototype of the object. Also improve assertions for `unset()`
tests.

Fix bug where `includeKey()` would be called with the wrong `this`
context.
Fix bug with `obj.set({})`

Move the check for whether there are any new props to be set so that it
happens before the check for whether the prototype can be reused.

Previously, the semantics of `sameKeys()` caused this case to
incorrectly traverse the prototype chain past the empty object.
Add callback to be called after `set()`s

Add a callback argument to the constructor that will be called after a
`set()` call results in a new object. The callback is called with the
new object as its argument. The callback is stored on the object as an
inenumerable property, `__callback`. This causes multiple calls to
`immutable()` to not return the strictly equal objects. Tests expected
this behavior were changed.

Change the constructor returned by `createClass()` to always use the
`ImmutableObject` constructor, passing the last argument as the
callback.