Enable SLPVectorizer and make it work for tuples

[Updated 2014-Nov-25] This pull request enables implicit vectorization of tuple math idioms when -O is on the Julia command line.   

The changes comprise:
* Add -O command-line option (per @ViralBShah's suggestion).
* Add LLVM's [BasicAliasAnalysis](http://llvm.org/docs/AliasAnalysis.html#the-basicaa-pass) and [SLPVectorizer](http://llvm.org/docs/Vectorizers.html#the-slp-vectorizer) to the pass list when -O is present.
* Add `InstructionCombiningPass` to clean up after ```SLPVectorizer```.  Without the cleanup, the code is horrible.
* Add a patch that makes LLVM 3.3's  ```SLPVectorizer``` work for tuply idioms of interest.
The changes to LLVM 3.3 were backported from recent changes developed by me that are now part of  LLVM 3.5.  The patch includes backported LLVM unit tests.
* Move position of  LoopVectorizer in the pass list to match its positions in Clang 3.3 and 3.5.  
  * For LLVM 3.3, it now comes after `LoopUnrollPass` instead of before.
  * For LLVM 3.5, it now comes almost last.
* When using LLVM 3.5, add a followup "InstructionCombiningPass".  Without the cleanup, the code is horrible. 

For background, see Issue #5857 and in particular my [comment](https://github.com/JuliaLang/julia/issues/5857#issuecomment-35784676).  Here is an example of what the enhanced SLPVectorizer can do:
```
$ cat foo.jl
function add( a::NTuple{4,Float32}, b::NTuple{4,Float32} )
    (a[1]+b[1],a[2]+b[2],a[3]+b[3],a[4]+b[4])
end

function mul( a::NTuple{4,Float32}, b::NTuple{4,Float32} )
    (a[1]*b[1],a[2]*b[2],a[3]*b[3],a[4]*b[4])
end

function madd( a::NTuple{4,Float32}, b::NTuple{4,Float32}, c::NTuple{4,Float32} )
    add(mul(a,b),c)
end

t = NTuple{4,Float32}

code_llvm(madd,(t,t,t))
$ julia -O foo.jl

define <4 x float> @"julia_madd;63815"(<4 x float>, <4 x float>, <4 x float>) {
top:
  %3 = fmul <4 x float> %0, %1, !dbg !45
  %4 = fadd <4 x float> %3, %2, !dbg !45
  ret <4 x float> %4, !dbg !45
}
```
Without the patch, the LLVM code for ```madd``` is [lengthy scalar stuff](https://gist.github.com/ArchRobison/9793916#file-gistfile1-txt).  

Impact on compilation time using -O using LLVM 3.3 is significant, but hardly noticeable withLLVM 3.5.  I measured compilation overhead using:
```
cd base; time -p ../julia sysimg.jl
```
Here's a table of compilation times (in seconds).  "Baseline" is Julia without the PR.

|                   | LLVM 3.3 | LLVM 3.3       | LLVM 3.3          | LLVM 3.5 | LLVM 3.5       | LLVM 3.5          |
|-------------------|----------|----------------|-------------------|----------|----------------|-------------------|
|                   | Baseline | PR | PR -O | Baseline | PR | PR -O |
| Run 1            | 46.40    | 46.83          | 67.65             | 53.74    | 51.57          | 53.33             |
| Run 2            | 46.50    | 46.56          | 67.63             | 51.94    | 51.70          | 53.13             |
| Run 3            | 46.40    | 47.06          | 67.13             | 52.32    | 51.80          | 52.80             |
| Run 4            | 46.32    | 46.24          | 68.28             | 52.31    | 51.83          | 52.84             |
| Run 5            | 47.12    | 46.53          | 67.79             | 52.43    | 51.51          | 53.01             |
| MEAN              | 46.55    | 46.64          | 67.70             | 52.55    | 51.68          | 53.02             |
| % w.r.t. baseline | 0.00%    | 0.21%          | 45.43%            | 0.00%    | -1.65%         | 0.90%             |
| STDEV/MEAN        | 0.70%    | 0.67%          | 0.61%             | 1.32%    | 0.27%          | 0.41%             |