The basic idea is to create very deep chains of operations to try to expose any
stack problems. We know that for things like map/flatMap Eval seems to work, so
let's just randomly construct deeply-nested Eval expressions to see what
happens.

This test exposed a weakness with .memoize which is fixed.

As part of this commit, I noticed that our Arbitrary[Eval[A]] instances were
somewhat weak, so I upgraded them.

…tests

This fix was proposed by @johnynek and fixes a bug I introduced with
how memoization was handled during flatMap evaluation. Our old
implementation did memoize intermediate values correctly (which meant
that three different evals mapped from the same source shared a
memoized value). However, it was not stack-safe. My fix introduced
stack-safety but broke this intermediate memoization.

The new approach uses a new node (Eval.Memoize) which can be
mutably-updated (much like Later). It's confirmed to be stack-safe and
to handle intermediate values correctly.

While it was unlikely that anyone was doing enough intermediate
memoization to cause actual stack overflows, it's nice to know that
this is now impossible.