It's not an accident really, dynamic dispatch is slow but expressive, static dispatch is fast but restrictive. Julia (as a language trying to solve the two-language problem) is designed to be approachable to Fortran programmers, so writing it like Fortran will work (and it will be just as fast because static is fast), and for Python programmers (which will lead to slower but highly dynamic code). Idiomatic Julia is actually a middle ground though, you always program at the highest level possible (you don't assume types, you assume behaviors, as the language is fundamentally duck typed like Python). The difference to CPython though is that the Julia compiler will generate one optimal static implementation for each possible argument combination that is used, instead of one dynamic implementation (as long as each implementation is not so expressive that can't be represented through a static code, which usually means depending on runtime information).
About the third point, it really won't matter in most other languages since in this case the Julia compiler is actually optimizing beyond those thanks to the multiple dispatch paradigm (in some cases it will even replace the function call directly with the result if it can solve it entirely with compile time information). And global variables in general can't be optimized by the compiler since they can be modified at any point, so it can't make any assumptions about it.
About the third point, it really won't matter in most other languages since in this case the Julia compiler is actually optimizing beyond those thanks to the multiple dispatch paradigm (in some cases it will even replace the function call directly with the result if it can solve it entirely with compile time information). And global variables in general can't be optimized by the compiler since they can be modified at any point, so it can't make any assumptions about it.