WIP: new DFT api

This is not quite ready to merge yet, but I wanted to bring it to your attention to see what you think.  It is a rewritten DFT API that provides:

* `p = plan_fft(x)` (and similar) now returns a subtype of `Base.DFT.Plan`.  It acts like a linear operator: you can apply it to an existing array with `p * x`, and apply it to a preallocated output array with `A_mul_B!(y, p, x)`.  You can apply the inverse plan with `p \ x` or `inv(p) * x`.
* It is easy to add new FFT algorithm implementations for specific numeric and array types...

Partly since we have discussed moving FFTW to a module at some point for licensing reasons, and partly to support numeric types like `BigFloat`, the patch also includes a pure-Julia FFT implementation, with the following features.

* One-dimensional transforms of arbitrary `AbstractVector`s of arbitrary `Complex` types (including `BigFloat`), with fast algorithms for all sizes (including prime sizes).  Multidimensional transforms of arbitrary `StridedArray` subtypes.
* Uses code generation (a baby version of the FFTW code generator) in Julia to generate kernels for use as base cases of the transforms; algorithms in general are FFTW1-like.
* Performance is reasonable. For moderate-power-of-two sizes, it is within a factor of 2 or so of FFTW, with the difference mainly due to the lack of SIMD.   ~~For non-power-of-two sizes, the performance is several times worse, but I suspect that there may be some fixable compiler problem there (a good stress test for the compiler).~~ (Non-power-of-two sizes seem fine with latest Julia).
* `import FFTW` is enough to automatically switch over to the FFTW algorithms for supported types.

Major to-do items:
- [x] Documentation
- [x] More test cases (implemented a self-test algorithm by Funda Ergün)
- [ ] Native Julia `rfft` support.
- [ ] Native Julia in-place transforms. (The 1d FFT algorithm here is out-of-place, but it could act "in-place" via a buffer.  The multi-dim FFTs only need a buffer of length `maximum(size(x))`.)

cc: @JeffBezanson, @timholy
In Julia v0.3v if I want to use FFTW for `Array{Float64,1}` but my own implementation for all other non-fftw-sizes (such as `Array{BigFloat,1}`), I cannot call my version `Base.fft{T<:Number}(X::StridedArray{T})` because `fftw.jl` defines that signature (approximately)  and calls `complexfloat` on the input. Is the same thing true here?