Call subscriptions of dependent nodes after subscriptions of their dependencies

Suppose that we have two observables with one subscriber each:

```coffee
a = new Bacon.Bus
b = a.map true
b.onValue -> console.log "b"
a.onValue -> console.log "a"
a.push 123
```

Currently, the order in which these subscribers will be called is unspecified. However, in simple cases they are called in the order of subscription, so the above code will print `"b"` then `"a"`. Things get more complicated when synchronization is involved:

```coffee
a = new Bacon.Bus
b = a.map yes
c = b.toProperty()
d = Bacon.combineAsArray a, c
e = d.changes()

callOrder = []
log = (name) -> () -> callOrder.push name

e.onValue log "e"
d.onValue log "d"
b.onValue log "b"
c.onValue log "c"
a.onValue log "a"

a.push 123
console.log callOrder

# outputs:
["c", "b", "a", "e", "d"]
```

With this patch, the side effects assigned to a dependent node will occur after side effects assigned to the node's dependencies, regardless of the order of subscription. The first snippet will output `"a"`, `"b"` and the second `["a", "b", "c", "d", "e"]`.

This is implemented by making `Dispatcher` process subscriptions with side effects before other ("internal") subscriptions. The changes are really simple and the performance shouldn't be affected.

I think that this behavior is more consistent than the current one. What do you think?
`waiters` is always null, so this function has no effect and can be safely removed.