…ignment.

This commit puts together the beginnings of an "interface" for detecting and avoiding aliasing between arrays before performing some mutating operation on one of them.

`A′ = unalias(dest, A)` is the main entry point; it checks to see if `dest` and `A` might alias one another, and then either returns `A` or a copy of `A`. When it returns a copy of `A`, it absolutely must preserve the same type. As such, this function is designed to be specialized on `A`, typically like:

    Base.unalias(dest, A::T) = mightalias(dest, A) ? typeof(A)(unalias(dest, A.a), unalias(dest, A.b), ...) : A

`mightalias(A, B)` is a quick and rough check to see if two arrays alias eachother.  Instead of requiring every array to know about every other array type, it simply asks both arrays for their `dataids` and then looks for an empty intersection between every pair.

Finally, `dataids(A)` returns a tuple of ranges that describe something about the region of memory the array occupies. It could be simply `(objectid(A):objectid(A),)` or for an array with multiple fields, `(dataids(A.a)..., dataids(A.b)..., ...)`.

And fixup the assumption that `broadcast!(f, C, A)` is safe

a builtin mapper method. Using varargs would require de-structuring the one arg case: `(a,) = unalias(dest, a)`.

…rray...

to only look at the linear data segment of its parent that it can reach

And a more accurate StridedArray dataids definition.

By defining `mightalias(::SubArray, ::SubArray)` we cover the vast majority of cases where extents are important. SubArrays are the basically only array in the standard library that "restrict" views into parents; all other wrappers largely re-shuffle the data. `dataids(::AbstractArray)` now just returns a tuple of `UInt`s that describe the identities of the mutable "blocks" that the array references.  By default, this is just `(objectid(A),)`, allowing all custom arrays to detect situations with two `===` arrays.  Anything more complicated requires them to define their component parts with a custom `dataids` method definition.

This will do what we want in almost all cases. We only hit this method if `A` is aliasing a mutable array... which means that `A` is mutable as well, and thus in many cases it has defined an appropriate `similar(A)` method that returns the same type.