Issue Description:

While trying to make a small improvement to SwiftLint by using https://github.com/apple/swift-evolution/blob/master/proposals/0223-array-uninitialized-initializer.md I came across an unexpected and interesting edge case.
This is the code that the evolution proposal uses for it's simple example:

var myArray = Array<Int>(unsafeUninitializedCapacity: 10) { buffer, initializedCount in
    for x in 1..<5 {
        buffer[x] = x
    }
    buffer[0] = 10
    initializedCount = 5
}
// myArray == [10, 1, 2, 3, 4]

On it's own this code is fine. What ends up not being fine is that when the Array.Element type is a class (or an unspecialized generic) `buffer[x] = x` crashes. It seems like it's doing an assignWithTake to release the old value, which makes sense for a class, but not for uninitialized data. I'm not entirely sure how the compiler would fix this, because there is nothing preventing you from doing something like:

buffer[0] = TestClass()
buffer[0] = TestClass()

and for the second write at an index the compiler would need to release for original instance.

This is an unsafe initializer after all, so if it can't be fixed it should at least be documented.
The documentation for this function is a bit light, doesn't contain any examples, so people are likely to go to the evolution proposal and try the first example. It would be better if the standard library documented the danger with using the subscript and instead directed people towards something like:

(buffer.baseAddress! + index).initialize(to: value)

SwiftLint Original PR here: realm/SwiftLint#3515

Reproduction code:

extension Array {
    func myMap<T>(transform: (Element) -> T) -> [T] {
        return Array<T>(unsafeUninitializedCapacity: count) { buffer, initializedCount in
            for index in indices {
                buffer[index] = transform(self[index])
            }
        }
    }
}

var array = [0, 1, 2, 3]

array.myMap { $0 + 10 }

final class TestClass {
    let index: Int
    
    init(index: Int) {
        self.index = index
    }
}

struct TestStruct {
    let index: Int
}

array.myMap { TestStruct(index: $0) }

array.myMap { TestClass(index: $0) } // This line crashes