Remove hard dependency on jQuery.Deferred quirks

jQuery.Deferred objects are not compliant with the Promises/A+ standard.
Replaces Promise#done() (not part of the standard) with Promises#then()

This fixes the jQuery.Deffered dependency discussed in #980.
It also exposes Marionette.Deferred as a means to configure the desired
implementation.

e.g.
```
Backbone.Marionette.Deferred = Q.defer; // kriskowal/q
Backbone.Marionette.Deferred = when.defer; // cujojs/when
```

docs/marionette.configuration.md

@@ -0,0 +1,37 @@
+# Marionette Configuration
+
+Marionette has a few globally configurable settings that will
+change how the system works. While many of these subjects are covered
+in other docs, this configuration doc should provide a list of the
+most common items to change.
+
+## Documentation Index
+
+* [Marionette.Deferred](#deferred)
+
+## Marionette.Deferred <a name="deferred"></a>
+
+By default, Marionette makes use of `Backbone.$.Deferred` to create
+thenable objects. All that is needed is a Deferred that has the
+following properties:
+
+1. `promise`: a Promises/A+ thenable, or a function that returns one
+2. `resolve`: a function that resolves the provided promise with a value
+
+For example:
+
+```js
+var deferred = Marionette.Deferred();
+
+_.result(deferred, 'promise').then(function (target) {
+    console.log("Hello, " + target + "!");
+});
+
+deferred.resolve("world"); // asynchronous "Hello, world!"
+```
+
+If you wish to use a specific promise library, you can override the default via:
+
+```js
+Marionette.Deferred = myDeferredLib;
+```

spec/javascripts/callbacks.spec.js

@@ -92,4 +92,31 @@ describe('callbacks', function() {
       expect(this.numCallbacks).to.equal(1);
     });
   });
+
+  describe("when Marionette.Deferred().promise is an object", function(){
+    beforeEach(function(){
+      this.sandbox = sinon.sandbox.create();
+
+      this.sandbox.stub(Backbone.Marionette, "Deferred", function(){
+        var deferred = Backbone.$.Deferred();
+        deferred.promise = deferred.promise();
+        return deferred;
+      });
+
+      var callbacks = new Backbone.Marionette.Callbacks();
+
+      this.spy = sinon.spy();
+      callbacks.add(this.spy);
+
+      callbacks.run();
+    });
+
+    afterEach(function(){
+      this.sandbox.restore();
+    });
+
+    it("should execute the callbacks", function(){
+      expect(this.spy).to.have.been.called;
+    });
+  });
 });

src/build/marionette.bundle.js

@@ -8,6 +8,9 @@ var Marionette = (function(global, Backbone, _){
   var Marionette = {};
   Backbone.Marionette = Marionette;
 
+  // Get the Deferred creator for later use
+  Marionette.Deferred = Backbone.$.Deferred;
+
 // @include ../marionette.helpers.js
 // @include ../marionette.triggermethod.js
 // @include ../marionette.domRefresh.js

src/build/marionette.bundled.js

@@ -31,6 +31,9 @@
 
   Backbone.Marionette = Marionette;
 
+  // Get the Deferred creator for later use
+  Marionette.Deferred = Backbone.$.Deferred;
+
   // @include ../marionette.helpers.js
   // @include ../marionette.triggermethod.js
   // @include ../marionette.domRefresh.js

src/build/marionette.core.js

@@ -31,6 +31,9 @@
   // Get the DOM manipulator for later use
   Marionette.$ = Backbone.$;
 
+  // Get the Deferred creator for later use
+  Marionette.Deferred = Backbone.$.Deferred;
+
   // @include ../marionette.helpers.js
   // @include ../marionette.triggermethod.js
   // @include ../marionette.domRefresh.js

src/marionette.callbacks.js

@@ -5,7 +5,7 @@
 // and executing them at a later point in time, using jQuery's
 // `Deferred` object.
 Marionette.Callbacks = function() {
-  this._deferred = Backbone.$.Deferred();
+  this._deferred = Marionette.Deferred();
   this._callbacks = [];
 };
 
@@ -15,26 +15,31 @@ _.extend(Marionette.Callbacks.prototype, {
   // guaranteed to execute, even if they are added after the
   // `run` method is called.
   add: function(callback, contextOverride) {
+    var promise = _.result(this._deferred, 'promise');
+
     this._callbacks.push({cb: callback, ctx: contextOverride});
 
-    this._deferred.done(function(context, options) {
-      if (contextOverride) { context = contextOverride; }
-      callback.call(context, options);
+    promise.then(function(args) {
+      if (contextOverride){ args.context = contextOverride; }
+      callback.call(args.context, args.options);
     });
   },
 
   // Run all registered callbacks with the context specified.
   // Additional callbacks can be added after this has been run
   // and they will still be executed.
   run: function(options, context) {
-    this._deferred.resolve(context, options);
+    this._deferred.resolve({
+      options: options,
+      context: context
+    });
   },
 
   // Resets the list of callbacks to be run, allowing the same list
   // to be run multiple times - whenever the `run` method is called.
   reset: function() {
     var callbacks = this._callbacks;
-    this._deferred = Backbone.$.Deferred();
+    this._deferred = Marionette.Deferred();
     this._callbacks = [];
 
     _.each(callbacks, function(cb) {