Added a case to deinterleave that works when transposing fixed sized blo...

Added a case to deinterleave that works when transposing fixed sized blocks of data. In this case we can safely interleave if the collected stores have unit stride, and each store is simply a load with a stride equal to the vector width. Adding this case makes this optimization a little easier to trigger when doing a simple transpose.

The last test in test/correctness/interleave.cpp demonstrates this. Prior to this change trans1 would not trigger the call to interleave_vector, whereas it is probably the more likely code that people would want to write. This change essentially allows us to interleave blocks of stores of the form:
```
    trans1[ramp(0, 1, 8)] = square[ramp(0, 8, 8)]
    trans1[ramp(8, 1, 8)] = square[ramp(1, 8, 8)]
    trans1[ramp(16, 1, 8)] = square[ramp(2, 8, 8)]
    trans1[ramp(24, 1, 8)] = square[ramp(3, 8, 8)]
    trans1[ramp(32, 1, 8)] = square[ramp(4, 8, 8)]
    trans1[ramp(40, 1, 8)] = square[ramp(5, 8, 8)]
    trans1[ramp(48, 1, 8)] = square[ramp(6, 8, 8)]
    trans1[ramp(56, 1, 8)] = square[ramp(7, 8, 8)]
```
whereas before we were only interleaving:
```
    trans2[ramp(0, 8, 8)] = square[ramp(0, 1, 8)]
    trans2[ramp(1, 8, 8)] = square[ramp(8, 1, 8)]
    trans2[ramp(2, 8, 8)] = square[ramp(16, 1, 8)]
    trans2[ramp(3, 8, 8)] = square[ramp(24, 1, 8)]
    trans2[ramp(4, 8, 8)] = square[ramp(32, 1, 8)]
    trans2[ramp(5, 8, 8)] = square[ramp(40, 1, 8)]
    trans2[ramp(6, 8, 8)] = square[ramp(48, 1, 8)]
    trans2[ramp(7, 8, 8)] = square[ramp(56, 1, 8)]
```
It's not obvious to me that this works in more than the one-layer-deep case. What if first_block->first is itself a chain of Blocks nested in a weird order?

E.g, what if the block is a balanced binary tree of blocks?

Here's a possible (untested) alternative:

    void visit(const Block *op) {
        vector<Stmt> stmts;
        stmts.push_back(op);

        for (int i = 0; i < (int)stmts.size(); i++) {
            if (Block *b = stmts[i].as<Block>()) {
                if (b->rest.defined()) {
                  stmts[i] = b->rest;
                  stmts.insert(stmts.at(i), b->first);
                  i -= 2;
                } else {
                  stmts[i] = b->first;
                  i--;
                }
            } else {
                stmts[i] = mutate(stmts[i]);
            }
        }

        Stmt result = stmts.back();
        stmts.pop_back();
        while (!stmts.empty()) {
            result = Block::make(stmts.back(), result);
            stmts.pop_back();
        }

        stmt = result;
    }