I understand your points, but they're not terribly relevant. This is a question of efficiency and memory footprint. If you absolutely need closure, you'll obviously use a syntax that provides closure. Otherwise you need to balance between maintainability (self-documenting, well-organized code) and efficiency. Most modern language do a great job of making things things the same. But even then, as is the case with JavaScript, there are nuances that have a clear edge.

Whether those edges are noticeable when they account for less than 1% of your execution time ... ?

keep in mind that there is a higher property-name resolution cost on prototypes than there is on own properties. If a prototype get chained 2 or 3 (or 20) levels deeps, there's a lot of potentials to strike off the list before the correct prototype appears.
An interesting concern. I'm not 100% sure it's valid though. Even in a true OOP language, I would expect most compilers to stuff a reference to the most relevant versions of a method directly in the end-class. And, since JavaScript has no implicit mechanism for inheritance, I'm not sure how this would prototype chain would occur unless you explicitly built it.

Could you show us what inheritance pattern(s) lead to this sort of prototype chaining? I'd be interested to benchmark it.