failed deinterleaving autovectorization

I tried this code:

fn good(input_buffer: &mut [f32], buf: &[f32]) {
    let (l, r) = input_buffer.split_at_mut(input_buffer.len() / 2);

    buf.chunks_exact(2)
        .zip(l.iter_mut().zip(r).map(<[_; _]>::from))
        .for_each(|(buf, sample)| {
            *sample[0] = buf[0];
            *sample[1] = buf[1];
        });
}

fn bad(input_buffer: &mut [f32], buf: &[f32]) {
    let (l, r) = input_buffer.split_at_mut(input_buffer.len() / 2);

    buf.iter()
        .zip(l.iter_mut().zip(r).flat_map(<[_; _]>::from))
        .for_each(|(buf, sample)| *sample = *buf);
}

I expected to see this happen: both versions compile to roughly the same code and are roughly the same speed.

Instead, this happened: good is successfully autovectorized, while bad isn't. I'm fairly sure there's no behavioral difference between the two, so the codegen difference seems odd.

Godbolt: https://godbolt.org/z/fohWsjEdr

Meta

rustc --version --verbose:

rustc 1.89.0 (29483883e 2025-08-04)
binary: rustc
commit-hash: 29483883eed69d5fb4db01964cdf2af4d86e9cb2
commit-date: 2025-08-04
host: x86_64-unknown-linux-gnu
release: 1.89.0
LLVM version: 20.1.7

Reproduce the good and bad functions from the issue with rustc 1.89.0, starting from the linked Godbolt example and comparing their generated code and vectorization. Done means the deinterleaved bad form receives equivalent autovectorization, or the code-generation difference is characterized and covered by an appropriate compiler test.