zeroize: use `asm!` to improve performance

[cbeck88]

The purpose of the change is to make calls to x.as_mut_slice().zeroize() considerably faster, particularly for types like [u8; n]. We take @sopium's proposed code from #743 without significant changes.

The reason it becomes faster is that the call to volatile_set before this change appears not to be easily optimizable, and (for example) leads to setting bytes one at a time, instead of the compiler consolidating them into SIMD instructions.

In the modified code, we don't use volatile_set, we instead loop over the slice setting the elements to Default::default(), and to ensure that the writes are not optimized out, we use an empty asm block. (There is discussion of the correct asm options to use here in the issue.)

Because the asm block potentially reads from the pointer and makes a syscall of some kind, the compiler cannot optimize out the zeroizing, or it could cause observable side-effects. In the improved code, we only create such an optimization barrier once, rather than after each byte that it is written.

The call to atomic_fence() is not changed.

---

This change may help give users a way to improve performance, if they have to zeroize very large arrays, or, frequently have to zeroize many small objects. We tested code-gen here in godbolt (in addition to the tests posted in the github issue) and found that this change is typically enough for llvm to start adding in SIMD optimizations that zero many bytes at once.