better description for .fork(), +.reject(), .timeout(), .all()
rename Promise.makeCallback -> .makeContinuation, refactor Promise.runAsync, fulfill/reject don't throw on resolved promises but silently do nothing
Trying an implementation based on the assimilation of promises

* removes a bunch of duplicate code:
  the only real case distinction between success and error happens at the
  level of the FullfilledPromise and RejectedPromise *primitives*
* much more efficient for deeply nested chain calls
  - it's a tail call optimisation of recursive promise "loops"
* a little ugly for the "normal" fulfill/reject callbacks of the Promise
  constructor, which now create extra instances. Does it matter?
little further optimisation

- inlined Promise.makeContinuation in the ResolvedPromise primitives,
  no more memoisation
* removed duplicate code in those 2 constructors
- moved Promise.makeResolver in the local scope of Promise
* renamed "resolve" functions to "assimilate"
+ new Promise.joinContinuations from the leftovers of makeContinuation,
  but no more parameters for callbacks
some performance considerations, deleted most of promise.todo which was specific to the old implementation
performance improvements

* ResolvedPromise.runner
* joinContinuations.runner
* Promise.all result callbacks

Also fixed Promise.all for empty promises lists
naming all functions
thoughts about cancellation
renamed Promise.timeout -> Promise.defer, +Promise.timeout for racing with a rejection, +Promise.from
trying to implement cancellation

* it's absolutely ugly (as expected)
* it seems to work though
+ implemented a Promise::send(message) pipeline for communication with resolver
* which is used by the cancellation process:
  (+) cancellation is not done in the Promise constructor
  (-) but every creator of a promise needs to manage everything itself :-/
* uses a token system, you can request one with .getCancellationToken()
  which prevents the cancellation of the promise
  until all the tokens given out have been cancelled
+ Promise.defer, Promise::defer for a delay
+ Promise.timeout, Promise::timeout for limiting the lifespan of a task
+ Promise.race for the fastest settling promise of a group,
  including cancellation of the losers
improved cancellation implementation

...a bit, at least. Still ugly.

* actual .send() pipeline
* getting CancellationTokens through send calls
+ cancellation for Promise.all & Promise.race
* refactored Promise.defer not to take a promise any more
lots of ideas about debuggability and execution of continuations
more questions on cancellation, and some ideas for an interoperable spec with 'send' and 'progress'
[minor] fix terminology
some ideas for progression
trying to implement cancellation

going by promises-aplus/cancellation-spec/issues/11: CancellationToken+
* it's not as ugly as the TokenSource on master branch
  but I still feel that it should be even less ugly
* changed .fork() signature to take an object
  which also can have a .token and an .assimilate callback attached
- cancelling handlers of resolved promises is buggy
+ implemented a .send(message) pipeline
* which is used for cancellation attempts
  relatively dry because of a 5-parameter addCancellationSend function
* timer methods, .all, .race have not yet been adapted.
Improvement of cancellation

* Fixed the bug with ignoring cancellation of handlers on resolved promises
* Fixed propagation of cancellation attempts
* replaced addCancellationSend monster by an implicitCancellationToken
  creator, and inlining the complete .send() function definition
+ ContinuationBuilder class to ease variadic joinContinuation calls
* rename Promise.joinContinuations -> ContinuationBuilder.join
* move noop-Promise::send on prototype
[minor] array parameter for ContinuationBuilder
Merge branch 'promise-assimilation'

Yeehaa! Conflicts in Promise.js and promise.todo were resolved, mostly by
adopting the promise-assimilation solution.

* Promise::defer, Promise.all, Promise.race are not working
* fixed a bug with continuation propagation of .chain() handlers that
  cancel the result promise
* added/merged a few explanatory comments
using AssimilatingPromise and new token cancellation for ::defer, .all and .race