Avoid using MemoryMarshal.Cast<byte, _> on Android

[AArnott]

This centralizes all uses of this API to a SafeBitConverter class which does the efficient thing except on Android, where we fall back to a safe pattern.

Fixes #931
See also #748, which was a similar fix but only to two call sites.

[AArnott]

@guo-sun Can you please test that this works for you?
@neuecc I haven't tested this on Android at all so please look meticulously during the review or if you have the means to test it, please do.

[gsuuon]

Yup this fixes the crash!

I had to add some casts to get this to compile, e.g here:

return (ushort)(value[0] | (value[1] << 8))

MemoryMarshal.Cast does some checks on TTo, TFrom which slows it down a bit - does it make sense to just use the bitwise code? I couldn't see a perf difference when I tried running the benchmarks in sandbox.

public static ReadOnlySpan<TTo> Cast<TFrom, TTo>(ReadOnlySpan<TFrom> span) where TFrom : struct where TTo : struct
{
	if (SpanHelpers.IsReferenceOrContainsReferences<TFrom>())
	{
		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(TFrom));
	}
	if (SpanHelpers.IsReferenceOrContainsReferences<TTo>())
	{
		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(TTo));
	}
	checked
	{
		int length = (int)unchecked(checked(unchecked((long)span.Length) * unchecked((long)Unsafe.SizeOf<TFrom>())) / Unsafe.SizeOf<TTo>());
		return new ReadOnlySpan<TTo>(Unsafe.As<Pinnable<TTo>>(span.Pinnable), span.ByteOffset, length);
	}
}

[AArnott]

Thanks for testing, @guo-sun. I've added the missing casts.
I suspect asking the CPU to read a 32-bit or 64-bit value is faster than asking it to read 8 8-bit values from contiguous memory. But if MemoryMarshal.Cast ever showed up on the perf trace due to validations, we could switch to Unsafe.As<T> which is what it uses internally after passing the checks.