Improve the interpretor

* Optimize when parallel actions are executed
* Simplify the code a little bit

src/core.js

@@ -581,9 +581,10 @@ Sequence.prototype._fork = function Sequence$_fork(rej, res){
 
   function early(m, terminator){
     cancel();
-    if(action !== terminator){
+    cold.clear();
+    if(async && action !== terminator){
       action.cancel();
-      while(async && (it = queue.shift()) && it !== terminator) it.cancel();
+      while((it = queue.shift()) && it !== terminator) it.cancel();
     }
     settle(m);
   }
@@ -602,14 +603,13 @@ Sequence.prototype._fork = function Sequence$_fork(rej, res){
       settled = false;
       cancel = future._fork(rejected, resolved);
       if(settled) continue;
-      action = action.run(early);
-      if(settled) continue;
       while(it = cold.pop()){
         it = it.run(early);
-        if(settled) break;
-        queue.unshift(it);
+        if(!settled) queue.unshift(it);
       }
       if(settled) continue;
+      action = action.run(early);
+      if(settled) continue;
       async = true;
       return;
     }

test/2.sequence.test.js

@@ -344,6 +344,17 @@ describe('Sequence', () => {
         setTimeout(done, 100, null);
       });
 
+      it('does not run actions unnecessarily when one early-terminates synchronously', done => {
+        const broken = new Sequence(Future(_ => { console.log('broken'); done(error) }));
+        const m = resolvedSlow.race(broken).race(broken).race(resolved);
+        m.fork(noop, _ => done());
+      });
+
+      it('resolves the left-hand side first when running actions in parallel', () => {
+        const m = new Sequence(of(1)).map(x => x).chain(x => of(x));
+        return assertResolved(m.race(of(2)), 1);
+      });
+
       it('does not forget about actions to run after early termination', () => {
         const m = new Sequence(after(30, 'a'))
                   .race(new Sequence(after(20, 'b')))