Allocation stack lowering based on escape analysis

Now that we can run libgo benchmarks:
https://codereview.appspot.com/103550047/
we can measure the effect of optimizations to see if they are worth adding
to the compiler.

This introduces an ssaopt package to hold SSA-level optimizations, to which
we add an allocation stack lowering pass based on a simple intraprocedural
escape analysis. In an experiment comparing libgo benchmark performance
before and after this change, this pass yielded a geo-mean 7.1% (5.5-8.7%
at a 95% confidence interval) improvement in performance.
Sorry, that was a poor example. I was trying to get across that a branch loop without phis is possible, and lowering to alloca may change program behaviour.

Hopefully this one illustrates my point more clearly:

```go
type T struct {
    val *int
}

func (t *T) f(val *int) bool {
    if t.val == val {
        return true
    }
    t.val = val
    return false
}

func main() {
    var q *int
    var t T
    for {
        q = new(int)
        if t.f(q) {
            break
        }
    }
}
```