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
No. Here it uses FFTW for single and double and the pure-Julia fallback otherwise. In general, the new design is such that it should be easy to plug in new FFT implementations for specific types. 

Even in Julia 0.3, if you define an fft method for a specific type like BigFloat, it will call your method instead of FFTW.