True mixins and updater fns obj > array

There are two main changes here. The first which is what I set out to
do, is that I am favoring true mixins over object inheritance. To make a
floating bubble an "Entity" "class" for example, I used to do this:

    // Call the "super" method with this context in the constructor
    Bub.Floater = function() {
        Bub.Mixin.Entity.call( this );
    };

    // Typical object inheritance pattern
    Bub.Floater.prototype = Object.create( Bub.Mixin.Entity.prototype );
    Bub.Floater.prototype.constructor = Bub.Floater;

Even though I called Entity a "mixin" I was still assigning the
prototype as plain old inheritance. Now, instead, I do this:

    // Now that Floater is an entity, call the setup method
    Bub.Floater = function() {
        this.entityify();
    };

    // Extend the prototype, don't overwrite it
    _.extend( Bub.Floater.prototype, Bub.Mixins.entity );

The main reasoning for doing this was more object composability. It
wasn't a true mixin I was using, even though that's what I initially
wanted. One downside is the instanceof check will fail for the mixin
level:

    new Bub.Floater() instanceof Bub.Mixins.entity // Cannot work

I am not concerned though, because Bub.Floater is still created with
"new" and you can `obj instanceof Bub.Floater` still. Also, if I go
fully mixined, there will be no more instance ofing. Entity will just
have some identifier, like type: 'entity' which will accomplish the same
thing.

The second refactor which came from exposing a bug from the mixins. The
'phys' updater was getting run last per loop because of how the mixins add it to
updateFns, but it needs to be run first so the object's position is
updated before other things work on it in the loop. I changed updateFns
from an object to an array so it executes in order.