Fix esoteric load `[DoubleInt<T>]` crash

[oscbyspro]

I stumbled upon this precondition failure (crash) while rewriting some tests. It is triggered by some esoteric conditions. In short, the arrays should contain Element where Element == Element.Element or its contents should be reinterpreted as Element.Element in these methods (the ones based on Contiguous sequences). The latter is more lenient, so I will try that first.

let _ = U32(load:   [] as [DoubleInt<U16>])
let _ = U32.init(   [] as [DoubleInt<U16>])
let _ = U32.exactly([] as [DoubleInt<U16>])

let _ = U64(load:   [] as [DoubleInt<U32>])
let _ = U64.init(   [] as [DoubleInt<U32>])
let _ = U64.exactly([] as [DoubleInt<U32>])

[oscbyspro]

Hm. I suppose I have some other options: I can require T == T.Element in DataInt<T>. Alternatively, I could change all reinterpretation beanches to compare T.Element.size instead (or fiddle with alignment). The former bans DataInt<U256> but it is easier to reason about.

[oscbyspro]

I suspect that requiring T == T.Element in DataInt<T> is the reasonable and responsible option because any type T that declares T != T.Element signals to the world that it is an unsuitable Element type. So DataInt<T.Element> would be preferred over DataInt<T.Element> so I might as well enforce that.

[oscbyspro]

I've already put the T == T.Element constraint on InfiniInt<T>, so there's some precedence for it. All SystemsInteger types also require that Element == Element.Element. It is just when the DataInt<T> comes from some unrelated container type where you might end up with a DataInt<SillyElement>.

[oscbyspro]

T == T.Element is the way. The type system immediately goes to work and tells me these 3 lines of code are bad. Love it.

[oscbyspro]

Tangentially, I had a design at some point with an additional Section associated type (although I'm not sure it ever made it into the public git history). In that design, the U256.Section == U256 while U256.Element == U64. It's basically a super-Element. It enables things like InfiniInt<U256> and it makes some generic reinterpretation strategies more powerful. But, it's more complicated and the benefit of it is small.