To Code and Beyond: A Neverland Adventure in Bash, Lua, Python, and Rust

If you really want "The quest?" to be "To discover the magic similarities and differences of the unique spirits of Bash, Lua, Python, and Rust." you need to rewrite all of the provided code examples in order to make them show actual deep insight into the "spirits" of these languages. A nice story-telling is one thing, but to dive into a "spirit" of a programming language requires a deep understanding of it you have missed to integrate into the provided code examples and explain in the text of the story.
If the goal of the quest is to sum all odd numbers in some range I suggest to use a much larger range as for example from 1 to 111 in order to be able to demonstrate the differences between the languages and focus then on the actual goal of printing the sum instead of choosing an unnecessary detour by using a function in first place.
Let's demonstrate what I am speaking about comparing bash, lua and python summing odd numbers in range from 1 to 111, both 1 and 111 included into the sum:

Bash:   a=({1..111..2});IFS=+;echo "$((${a[*]}))"
Lua:    s=0;for i=1,111,2 do s=s+i end;print(s)
Python: print(sum(range(1,112,2)))

-- Bash "spirit" is to use the mechanisms of substitutions all prefixed by the "$" sign. So bash is about DOLLARs, pipes and different kinds of braces.
-- Lua "spirit" is to focus on small size of the executable, so there is for example no support for unary "+=" as it would require more code for the parser
-- Python "spirit" is to come with "batteries included", since the ready to use sum() and range() functions. Python "spirit" is also to exclude the upper value from being part of the created range, so you need to specify 112 as upper range limit to include 111 in the range.

Sorry, but I am not (yet) familiar with the "spirit" and all the specifics of Rust (the reason why I don't provide a Rust code example), so maybe someone else with deep understanding of Rust can help out?

NOTICE that also Bash is equipped with the modern way of "hiding" the actual loop you seem not to be aware of providing the bash example code without mentioning this like you mention it in the context of Python and Rust.

For me what makes the shell something unique are pipes:

seq -s+ 1 2 5 | bc

A killer one-linner proves that

Maybe worth to mention in this context is the obesity of the Python "spirit" compared to the slim and lightweight "spirit" of Lua (check out the download sizes for the Lua and Python interpreter to see yourself how "obese" Python is when compared to Lua).
Below a code example with pre-defined functions in Lua allowing to achieve the code brevity of Python for the task of summing odd numbers in the given range. Is skipping this small piece of preliminary code worth a download size beyond 15 MByte for the interpreter?

#!/bin/lua
function rangeGenerator(...) --[[
    Use in case of large arrays to avoid allocation of memory holding the entire range if 
    your goal is to iterate/loop over the range values only                         ]]
    local n_args = select("#", ...)
    local increment = 1
    if n_args == 1 then     from, to = 0, ...
    elseif n_args == 2 then from, to = ...
    elseif n_args == 3 then from, to, increment = ...
    else error"range requires 1-3 arguments" end
    local i = from
    return function()
    if i > to then return end --[[ NOTICE that the 'to' value will be included in the range ]]
        local prev_i = i
        i = i + increment
        return prev_i
    end
end
function range(...) --[[ 
    Returns a TABLE holding all of the generated range values, so use it only for small
    table sizes if the goal is to iterate over the table values, else use rangeGenerator() ]]
    local n_args = select("#", ...)
    local increment = 1
    if      n_args == 1 then from, to = 0, ...
    elseif  n_args == 2 then from, to = ...
    elseif  n_args == 3 then from, to, increment = ...
    else error"range requires 1-3 arguments" end
    r={};for i=from,to,increment do r[#r+1]=i end
    return r
end
function sumRange(...)
    s=0;for i in rangeGenerator(...) do s=s+i end
    return s
end
function sum(a)
    s=0; for _,v in ipairs(a) do s=s+v end
    return s
end

s=0;for i=1,111,2 do s=s+i end;print(s)
print(sumRange(1,111,2))
print(sum(range(1,111,2)))

The code above demonstrates how Lua copes with lowering memory requirements providing a mechanism comparable to Python generator functions. Notice that Lua supports multiline comments (you can even nest them using --[=[ multiline comment of higher order --[[ with lower order comment ]] inside it ]=] )

Sir, your writing style is brilliant

Great Story, Like it 🔥

Replace in the bash code the unnecessary double echoing
echo $(sum_odd_int_array "${array[@]}")
with
sum_odd_int_array ${array[@]}