Fix Issue 2834 - The GC will now call destructors on heap allocated structs

~~This PR is not quite ready to merge, as I need to add a set  of tests for it, and also need to get it to work on arrays of structures as well. I am creating it now to make sure that I've not gone and broken druntime terribly with my approach to fixing the issue, as well as to take feedback on my method of solving the issue.~~ And the link to the issue this solves is [here](https://issues.dlang.org/show_bug.cgi?id=2834).

In the case where a struct is a member of a class, the struct's destructor will be called after the body of the class's destructor.

This PR is now ready to be reviewed and hopefully merged. It is not feasible to implement calling destructors of structs in heap allocated arrays for various reasons, including the inability to know which elements of the array are actually initialized, as well as which elements are valid.

This requires D-Programming-Language/dmd#3727

https://issues.dlang.org/show_bug.cgi?id=2834
`__d_arrayShrinkFit` is not meant to be called directly. The only way it is called is from `assumeSafeAppend`.

This should be and should remain valid code:

```D
auto a = new byte[100];
b = a[0..5];
b.assumeSafeAppend;
a.assumeSafeAppend; // would trigger the assert.
```
Again, any time `assumeSafeAppend` is called, we are assuming the caller knows what he is doing.

I think it would be valid to assert that the new size fits in the block, but not that it is less than the old size. However, I'm not sure it's actually *harmful* to allow this, since all you are doing is setting a variable inside the block. It probably just means the append will reallocate.

Note that the only way to achieve this is to disregard the block size itself:

```D
auto a = new byte[100];
a = a.ptr[0..a.capacity+50];
a.assumeSafeAppend;
```
Which means you're in memory corruption territory already.