This op takes care of the special case when the entries of scan are not in
the righr order. Such a thing can happen once the save mem optimization is
implemented, and the memory buffer for an output is much smaller then the
number of steps. Then scan will just roll around that memory buffer, and
entry 0 might end up somewhere in the middle

Before this class was used to validate that computing the shape of an
argument does not rely on any input of the inner function of scan. We do not
need to do this anymore, since now the output storage size is given as input
to scan, and output shapes are the same as input shape (so the internal
graph of scan does not come into play anymore).

This way we make sure that no gpu argument gets there

The previous code was copy paste from the old scan and it did not respect
the new scan internals.

I've changed the __eq__ of scan by moving a much more obvious check up in
the function

Before I used to have the different types of inputs/outputs seperated into
lists inside the scan op. I've made a more generic approach, where there is
a simple list of all inputs/outputs for scan.

Construct an instance of the Scan Op and apply it to inputs

The distinction between different types of inputs/outputs is not really
necessary anymore, so in order to simplify the code I just create a single
list of all inputs

I keep track of the original shared variables, plus remove the distinction
between outer and inner since is not needed anymore.

I do not really use ``states_and_outputs_info`` list anywhere after that
point. I will use mintaps however. Normally I would have to feel both lists
with the defaul, but since I'm not using the first one anymore, I'll just
fill the second one

I will use ``cond`` as ``as_repeatUntil`` because both variables have the
same semantics

Note : some of them are copies of the ones in the old scan