Fixes for emplace struct

Contains various fixes for emplace!struct that I happened upon:
* From 8763 http://d.puremagic.com/issues/show_bug.cgi?id=8763 : This was preventing certain structs from default emplacing. EG: "S s = void; emplace(&S);"
* Given a struct with an opAssign, emplace was calling opAssign without first copying over T.init: This creates undefined behavior if the opAssign actually did anything on this, such as deleting a payload, or copying to a payload.

I re-implemented "most" of emplace!Struct to outright bypass opAssign when possible by doing a move directly "onto" the un-initialized chunk. There is only one case where opAssign is called: If there is absolutely no way to construct a T without it.

The way emplace!struct reimplemented is pretty straight forward, trying (conveniently numbered) cases, and finally giving up with a verbose message. "Don't know how to emplace..."

Also added a message in "initalize" regarding the need to access "T.init". Note that I did not change the existing behavior, merely asserted it with a message.

Pretty chunky unit tests added too, for coverage.

```D
T* emplace(T, Args...)(T* chunk, Args args)
    if (is(T == struct))
{
    auto result = cast(typeof(return)) chunk;

    //Copies T.init over destination
    void initialize(T* dest, size_t size = T.sizeof)
    {
        static assert(is(typeof((inout int _dummy=0){static T i;})),
                      text(T.stringof, " is not emplaceable because it has @disable this()."));
        static T i;
        memcpy(dest, &i, size);
    }

    //From std.algorithm.move, but without destroying destination (since it is uninitialized).
    void moveOver(ref T source)
    {
        memcpy(result, &source, T.sizeof);
        // If the source defines a destructor or a postblit hook, we must obliterate the
        // object in order to avoid double freeing and undue aliasing
        static if (hasElaborateDestructor!T || hasElaborateCopyConstructor!T)
        {
            static if (T.tupleof[$-1].stringof.endsWith("this"))
            {
                // Keep original context pointer
                initialize(&source, T.sizeof - (void*).sizeof);
            }
            else
            {
                initialize(&source);
            }
        }
    }

    static if (Args.length == 0)
    { // 1.
        // Short circuit before trying anything fancy.
        // Also, this helps protect from @@@BUG@@@ 8763 in case 3.
        initialize(result);
    }
    else static if (is(typeof(result.__ctor(args))))
    { // 2.
        // T defines a genuine constructor accepting args
        // Go the classic route: write .init first, then call ctor
        initialize(result);
        result.__ctor(args);
    }
    else static if (is(typeof(T(args))))
    { // 3.
        // Struct without constructor that has one matching field for
        // each argument. Construct and move over
        auto t = T(args);
        moveOver(t);
    }
    else static if (Args.length == 1 && is(Args[0] == T))
    { // 4.
        //Exact type match: Move args[0] directly (not a copy)
        moveOver(args[0]);
    }
    else static if (Args.length == 1 && isAssignable!(T, Args[0]))
    { // 5.
        //T does not have any form of constructor that accepts args[0],
        //But it has an opAssign that accepts it. Use it.
        static if (is(typeof(result.opAssign(args[0]))))
            initialize(result); //result has elaborate assignment, so init first.
        *result = args[0];
    }
    else
    {
        //Give up
        static assert(0, text("Don't know how to emplace a ", T.stringof, " with ", Args[].stringof, "."));
    }

    return result;
}
```