Missed optimization in sum of remainders

I tried these codes:

const N: usize = 100000;
#[unsafe(no_mangle)]
fn foo0(n: usize) -> usize {
    // assert!(n > 0);
    if n == 0 {
        return n;
    }
    let s = (0..N).map(|i| i % n).sum();
    s
}

const N: usize = 100000;
#[unsafe(no_mangle)]
fn foo1(n: usize) -> usize {
    // assert!(n > 0);
    if n == 0 {
        return n;
    }
    let mut s = 0;
    let (q, r) = (N / n, N % n);
    if q > 0 {
        s += q * (n - 1) * n / 2;
    }
    if r > 0 {
        s += (r - 1) * r / 2;
    }
    s
}

I expected the loop in foo0 to be optimized away to a result similar to foo1.

Start by reproducing the foo0 and foo1 entry points from the issue and comparing their generated code. Trace the compiler's handling of the remainder loop; done means foo0 is optimized to behavior comparable to foo1 without changing the demonstrated results.