Should extension methods/parent methods be used vs normal methods?

Looking at https://github.com/lampepfl/steps/blob/febe88e2f5db95ea6739aacda955eff3f729d03b/src/main/scala/steps/result/package.scala

It appears that most of the code relies on an enum with extension methods or methods in the parent, vs defining the methods in the child classes.

Won't this potentially limit JVM optimizations? Consider the following example (https://godbolt.org/z/48rqPqE75)

  def example(x: Result[Int, Int]): Iterator[Int] =
    x match
      case xx: Result.Ok[Int]   => xx.iterator
      case _: Result.Err[Int] => 
        println("ERROR")
        Iterator.empty

Note that the call to xx.iterator will call Ok.Iterator directly.
In the current implementation, this will do another instanceof check, which would be avoided if the methods were defined in the child classes.

I understand that this is a micro optimization, but if the plan is to move this to the stdlib, we might as well make sure that it's performant.

Start with src/main/scala/steps/result/package.scala and compare the enum extension and parent methods with methods on the child classes. Reproduce or inspect the JVM behavior in the linked Godbolt example, then determine whether the implementation should change for performance. Done means reaching and documenting a clear design decision; no project test is named in the issue.