Stretch optimization

This request speeds up main Pillow functionality: image resizing. It also includes changes from #970.

## Main part

I've changed the traversal order of the pixels.

**Old**: There are two passes: horizontal and vertical stretch. In horizontal pass pixels are iterated from left to right first, then from top to bottom. That allows to calculate coefficients for each row only once, but is very inefficient for CPU cache. In vertical pass the order of traversal is changed: from top to bottom first, then from left to right, but calculation of each pixel of destination image requires pixels from different lines of source image.

**New**: Stretch always works in horizontal direction, pixels are iterated from top to bottom first, then from left to right. Calculation of each pixel in destination image requires only pixels from the same line of source image. CPU cache is used as efficiently as possible. Coefficients for each column are calculated in advance and stored separately, which prevents overheads. For vertical stretch image is transposed and stretched in horizontal direction again. Then it is transposed again to match the original image. Transposition is also made in effective for the CPU cache way: in block of 64 pixels (16kb).

## Other optimizations

Effective cache usage allows other optimizations. In common this is using of integer numbers insted of floats when possible. Also, huge boost was given by bands loop unrolling.

## Benchmarks

I've tested performance before and after this changes. Also i've tested GraphicsMagick 1.3.18 with following filters: `antialias ` = `lanczos`, `bicubic` = `catrom`, `bilinear` = `triangle`.

Source image: http://www.apple.com/imac-with-retina/5k.html

Filter | Destination size | GM              | Before           | After             |
-------|------------------|-----------------|------------------|-------------------|
**Antialias** | 2048×1152 | **0.88 s** 17 Mpx/s | **1.016 s** 14 Mpx/s | **0.421 s**  35 Mpx/s |
              | 320×240   | **0.65 s** 23 Mpx/s | **0.473 s** 31 Mpx/s | **0.225 s**  66 Mpx/s |
**Bicubic**   | 2048×1152 | **0.64 s** 23 Mpx/s | **0.840 s** 18 Mpx/s | **0.326 s**  45 Mpx/s |
              | 320×240   | **0.37 s** 39 Mpx/s | **0.326 s** 45 Mpx/s | **0.154 s**  96 Mpx/s |
**Bilinear**  | 2048×1152 | **0.42 s** 35 Mpx/s | **0.650 s** 23 Mpx/s | **0.237 s**  62 Mpx/s |
              | 320×240   | **0.19 s** 78 Mpx/s | **0.184 s** 80 Mpx/s | **0.082 s** 180 Mpx/s |

Test source:
```python
from PIL import Image
import time

def timeit(n, f, *args, **kwargs):
    def run():
        start = time.time()
        f(*args, **kwargs)
        return time.time() - start

    return min(run() for _ in range(n))

n = 20
image = Image.open('5k_image.png').copy()
print 'warmup', timeit(n // 4, image.im.stretch, (2048, 1152), Image.ANTIALIAS)
print 'Antialias | 2048x1152 | {:.4}'.format(timeit(n, image.im.stretch, (2048, 1152), Image.ANTIALIAS))
print 'Antialias | 320x240   | {:.4}'.format(timeit(n, image.im.stretch, (320, 240),   Image.ANTIALIAS))
print 'Bicubic   | 2048x1152 | {:.4}'.format(timeit(n, image.im.stretch, (2048, 1152), Image.BICUBIC))
print 'Bicubic   | 320x240   | {:.4}'.format(timeit(n, image.im.stretch, (320, 240),   Image.BICUBIC))
print 'Bilinear  | 2048x1152 | {:.4}'.format(timeit(n, image.im.stretch, (2048, 1152), Image.BILINEAR))
print 'Bilinear  | 320x240   | {:.4}'.format(timeit(n, image.im.stretch, (320, 240),   Image.BILINEAR))
```
In my opinion, having a functions named `Foo` and `Foo2` is a naming failure and not something that I want to continue. (I don't necessarily want to go back and fix all of them, yet, or at least now...). The function name is the most valuable way to figure out what the function does. `Foo` and `Foo2` requires going in and looking at the docs or reading the code. I like the pair of names, `ImagingTranspose`, and `ImagingTransposeToNew`.