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.
Ah, right, I hadn't considered address uniqueness.

> I think that we can detect such cases by checking whether a (directly or indirectly) referred phi node dominates the allocation.

I'm not sure that's quite enough. Consider:

```go
package main

func main() {
    var p, q *int
    for {
        q = new(int)
        p = q
        if true {
            break
        }
    }
    println(p, q)
}
```

```
func main():
0:                                                                entry P:0 S:1
	jump 1
1:                                                             for.body P:2 S:2
	t0 = new int (new)                                                 *int
	if true:untyped bool goto 2 else 1
2:                                                              if.then P:1 S:0
	t1 = println(t0, t0)                                                 ()
```