Er, I am not too good in this, but that's not the take-away, I think.
While there are some bugs still, the goal for Swift (6+) is definitely to be able to say "there are no warnings in my code about data races, so there are none".
The fact that you don't see a warning at the callsite of stockPriceIndexNonIsolatedActor does indeed mean there is no data race here. The call happens in the global actor isolation context [1] and that is the same context the function is defined on (inside the Korea class). The only parameter that is passed here (korea, which becomes self inside the method, this is basically passed implicitly as that's the instance the method is called on) is not Sendable, but since you do not cross an isolation context, that does not matter.
The warning at the callsite of stockPriceIndexMainActor is correct as the korea instance here is inside the global actor isolation context, but since the called method is marked to be run on @MainActor (and korea/self is passed like before), is now crossing an isolation context, which is forbidden.
In other words: If a jump happens, it's only important what is passed: Is it Sendable? Fine! Is it not? Dang, the compiler warns!
If there is no switch between isolation contexts at all, this does not matter.
Note that a suspension point (await) does not necessarily mean the isolation context is switched, even if the global actor executor may switch threads internally. Perhaps this is the mechanism you mean?
[1]: See my other post below. Basically all your async functions run inside a task, but it's all structured until you start a Task { ...}. See also the nifty image posted here.