Analyzer Fusion order of operations

I noticed that the analyzer's fusion module struggles with a particular pattern:

```haxe
@:analyzer(fusion_debug)
function main() {
var a = getValue();
var b = getValue();
var c = [a, b];
trace(c);
}

@:pure(false)
function getValue() {
return 1;
}
```

Here's what happens:

1. It attempts to fuse `a`, but fails due to the side effect on `var b = getValue()`.
2. It then attempts to fuses `b`, and succeeds.
3. Because something has changed, the algorithm re-enters and then successfully fuses `a`.

While this doesn't look particularly bad at first glance, it scales really poorly. The problem is that every additional variable causes an additional pass to be run over the entire expression. This is facilitated by the transformer generating lots of temporary variables which are then fused together.

I'm thinking that forward searching is _generally_ the right approach for this algorithm, but subsequent variables should first be "collected" and then processed in reverse order.