Everything is readable in small examples.

What matters is that a language remain mutable at scale:

• 10 parameters.
• Random [10, 20] characters per name & type.
• 10s of lines of code.

Your Rust code is completely unidiomatic, so it's a bogus comparison:

• Idiomatic Rust does not use globals.
• Idiomatic Rust does not use pointers.
• WTF are you using black_box for???

Rewritten, with inline comments explaining the choices for folks not used to Rust:

fn fill_array_idiomatic(max_val: i32, darr: &mut Vec<i32>) {
    darr.clear();

    darr.extend(0..max_val);
}

fn fill_array_for(max_val: i32, darr: &mut Vec<i32>) {
    darr.clear();

    for i in 0..max_val {
        darr.push(i);
    }
}

fn calc_sum_idiomatic_i32(darr: &[i32]) -> i32 {
    //  Type inference for `sum` generally sucks, for some reason.
    //
    //  The type of its output is known (return type), yet must be specified...
    darr.iter().sum::<i32>()
}

fn calc_sum_for_i32(darr: &[i32]) -> i32 {
    let mut sum = 0;

    for i in darr {
        sum += i;
    }

    sum
}

fn calc_sum_idiomatic(darr: &[i32]) -> i64 {
    //  Using `as` is not recommended.
    //
    //  It works, but it can do _anything_: lossless casts, lossy casts,
    //  integer to float, integer to pointer, etc...
    //
    //  Into should be used for lossless casts... but:
    //  - Since `sum` accepts _anything_, type inference is unable to know what we
    //    wish to convert to, requiring a type annotation.
    //  - `<&i32 as Into<i64>>` does not exist, so we must dereference `i` first.
    darr.iter().map(|&i| -> i64 { i.into() }).sum::<i64>()
}

fn calc_sum_for(darr: &[i32]) -> i64 {
    let mut sum = 0;

    for &i in darr {
        let i: i64 = i.into();

        sum += i;
    }

    sum
}

There is no pointer version, because nobody sane would use a pointer version. Pointers are to be used sparingly in Rust, as each use must be carefully annotated with comments discharging soundness obligations.

(I mean, ideally it should be the same in C or C++, but they're so omnipresent it would be untenable...)