Make unary ops more efficient with non-contiguous inputs

[robertknight]

Unary operators (eg. sigmoid, tanh) are much less efficient with non-contiguous inputs. The problem is two-fold:

• For SIMD-vectorized operators (eg. tanh), the fast path calls a SIMD function that applies the operator to the entire contiguous buffer at once. For non-contiguous inputs, it falls back to iterating over the input and applying the operator on one element at a time. Even worse, the fast path is parallel whereas the fallback is not
• In the slow path for TensorBase::apply, it uses an iterator which is much less efficient than iterating over contiguous inputs. See also Replace all usage of TensorBase::broadcast_iter #189.

A better implementation would be something like:

• Sort dimensions into maximally-contiguous order
• If the size of the longest contiguous chunks is above a threshold, iterate over them and apply the operator
• If the size is below the threshold, use nested loops instead of an iterator, ala. Replace all usage of TensorBase::broadcast_iter #189

Once this is done, copying activations in RNN operators (eg. GRU, LSTM) can be replaced with their in-place versions to reduce copying.

• Change TensorBase::apply to avoid using an iterator (Improve slow-path performance for unary ops #223)
• Add better slow path for SIMD-vectorized unary ops