[New Feature] Fastfood

Implementation of the Fastfood algorithm by @felixmaximilian and @esc
 
We have been working on this code for quite some time now and we think that it is mostly ready for some public review. There may still be a few wrinkles to iron out but in general the code is in decent shape.

For details of the algorithm, see the documentation at:

https://github.com/esc/scikit-learn/blob/fastfood/sklearn/kernel_approximation.py#L503

Also check out the example usage:

https://github.com/esc/scikit-learn/blob/fastfood/examples/kernel_approximation/plot_digits_classification_fastfood.py

And the performance evaluation at:

https://github.com/esc/scikit-learn/blob/fastfood/examples/kernel_approximation/rks_vs_fastfood.py

To minimize dependencies we included an cython in-place implementation of the Fast Hadamard Transform:

https://github.com/esc/scikit-learn/blob/fastfood/sklearn/utils/cyfht.pyx

For ease of merging, the branch has been rebased against current master at the time of writing, prior to the pull-request.
Yes @dougalsutherland, releasing the gil improved the performance again onto the same level as without memoryviews. But its actually not faster. The reason might be, that the memoryview is not just used for accessing the data but for altering it as well. Or should that make no difference?
The code looks like that:
```python
def is_power_of_two(input_integer):
    """ Test if an integer is a power of two. """
    if input_integer == 1:
        return False
    return input_integer != 0 and ((input_integer & (input_integer - 1)) == 0)

def fht(cython.floating[::1] array_):
    """ Single dimensional FHT. """
    if not is_power_of_two(array_.shape[0]):
        raise ValueError('Length of input for fht must be a power of two')
    else:
        _fht(array_)


@cython.boundscheck(False)
cdef void _fht(cython.floating[::1] array_) nogil:
    cdef unsigned int bit, length, _, i, j
    cdef cython.floating temp
    bit = length = array_.shape[0]
    for _ in xrange(<unsigned int>(log2(length))):
        bit >>= 1
        for i in xrange(length):
            if i & bit == 0:
                j = i | bit
                temp = array_[i]
                array_[i] += array_[j]
                array_[j] = temp - array_[j]

def fht2(cython.floating[:, ::1] array_):
    """ Two dimensional row-wise FHT. """
    if not is_power_of_two(array_.shape[1]):
        raise ValueError('Length of rows for fht2 must be a power of two')
    else:
        _fht2(array_)


@cython.boundscheck(False)
cdef void _fht2(cython.floating[:, ::1] array_) nogil:
    cdef unsigned int n
    n = array_.shape[0]
    for x in xrange(n):
        # TODO: This call still shows up as yellow in cython -a presumably due
        # to the [] access, but the array_ is already typed...
        _fht(array_[x])
```
What I didn't try is to do the trick with memoryviews and pointers as mentioned in the [article](https://jakevdp.github.io/blog/2012/08/08/memoryview-benchmarks/), because I don't understand the difference until now.