`core.atomic.atomicLoad`'s returns types have changed for aggregate types that have indirections.

$(REF atomicLoad, core,atomic) used to strip the `shared` qualifier off too
eagerly. When an aggregate type has a "head" and a "tail", connected by an
indirection, then `atomicLoad` used to strip `shared` off the tail. That was a
bug ($(BUGZILLA 16230)). `atomicLoad` only loads the head. The tail remains in
shared memory, and must keep the `shared` qualifier.

When loading a struct that contains indirections, `atomicLoad` now returns a
wrapper that provides getters which return properly typed values.

When loading a class reference, `atomicLoad` now leaves the `shared` qualifier
on.

Example:
----
class C { int value; }
shared C shc = new C;

struct S { int head; int* tailPointer; }
shared int tail = 1;
auto shs = shared S(2, &tail);

void main()
{
    import core.atomic : atomicLoad, atomicOp;

    // Loading a class reference:
    shared C c = atomicLoad(shc);
    // c itself is not actually shared. It's safe to copy it non-atomically:
    shared C c2 = c; // ok
    // c's fields are still shared and need to be loaded atomically:
    int v = atomicLoad(c.value);

    // Loading a struct that has an indirection:
    auto s = atomicLoad(shs);
    // The struct's head has been copied and can be modified non-atomically:
    ++s.head;
    // The tail is still shared and needs to be handled atomically:
    shared(int)* t = s.tailPointer;
    atomicOp!"+="(*t, 1);
}
----
