I personally don't like the fact that you have structs but no classes and no instance methods, but I know this is personal and don't want to start a religious war this morning
Also in static languages, the set of available instance is closed and extending it requires approaches like extension methods now available in a couple of OOP languages.
Whereas multi-methods are dynamically dispatched taking into consideration the whole set of parameters, and can be defined after the fact. Meaning that they aren't necessarily written in the same module that defines the respective data structures, which opens the door to more extensible designs.
Taking the Alan Perlis' quote "It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures." to the next level.
Because not only can you define all those functions that operate on one data structure, they actually apply to the tuple made by the dynamic type of all parameters at call site.
Naturally it also might make it harder to follow what actually happens with a given method dispatch.
This is my insight from having gone through "The Art of the Metaobject Protocol" and dabbling with multi-methods in Clojure, so I might not be 100% correct here.
Building on top of your remark, Julia's approach is more "call the visible implementation of this function that better matches the types of all given parameters".
And these are only two possible ways of doing OOP, there are a few other ways of approaching the ideas of writing extensible modular code with polyphormism.
In other words: object orientation != strong typing (even if they do tend to go hand-in-hand).
CLOS, Beta, SELF, Oberon (the first version), Component Pascal all have explored different ways of doing OOP.
Or that you have to say foo(x) instead of x.foo()?
The latter makes writing code using autocomplete less doable, but reads more naturally in many cases.
I can't think of compelling pragmatic reason to mind the former, but if you have one I'd like to hear it.
But the problem is not that big. Maybe the methods are right next to the struct, or if I search the codebase for the struct I can find which methods use it. Still, would be cool if Juno had some feature like "show which methods use this."