UFCS reduce

From the discussion: http://forum.dlang.org/thread/jorsc4$kvo$1@digitalmars.com

The development can be seen as being in 3 parts:

I. The first step was to get rid of that weird Args... interface reduce had going on, and replace it with explicit variables. From there, the implementation was split into 4 easy to call functions:

```D
auto reduceImpl(R)(R r) if (isInputRange!R)            //Input range w/o seed

auto reduceImpl(R, S)(R r, S seed) if (isInputRange!R) //Input range w seed

auto reduceImpl(R)(R r)            //opApply w/o seed
    if (!isInputRange!R && isIterable!R)

auto reduceImpl(R, S)(R r, S seed) //opApply w seed
    if (!isInputRange!R && isIterable!R)
```

This splice was mainly about splitting static ifs, and removing the now useless aliases. It is not possible to see it in the diff, but the only thing that went on here was code shuffling. Not a single new line of code was written during the splice.

II. The second step was the "public entry point" for the template itself, that will dispatch to the right function. Not much to see here actually.

III. The third step was a deprecation plan.

```D
    /**
     * No-seed version: The first element of $(D r) is taken as the seed. $(D r)
     * must not be empty.
     */
    auto reduce(R)(R r)
        if (isIterable!R)
    {
        return reduceImpl(r);
    }

    /**
     * Standard signature: The elements of $(D r) are reduced into $(D seed)
     */
    auto reduce(R, S)(R r, S seed)
        if (isIterable!R && !is(typeof(reduceImpl(seed, r))))
    {
        return reduceImpl(r, seed);
    }

    /**
     * $(RED Scheduled for deprecation. Please prefer 
     *        the other, UFCS compatible, signature)
     *
     * Old signature: Same as $(D reduce(r, seed))
     */
    auto reduce(S, R)(S seed, R r)
        if (isIterable!R && is(typeof(reduceImpl(r, seed))))
    {
        return reduceImpl(r, seed);
    }
```

This scheme is a bit complicated, but clean, and necessary. If and when we completely deprecate and remove the old call convention, it can be cleaned up, and the template restrictions made tighter/clearer.

AFAIK: This change CANNOT break existing code. The existing unittests were not changed a single line. They were also duplicated using the new call scheme. Both work.

EDIT: This pull can now break code.

Open to any feedback.