In very disappointing news proper tail calls are out of ES4. It seems that a justification for tail calls could not be found. For example, here is Adobe's position on tail calls:
A more serious point is that we can't avoid adding tail calls at some point if we cater to the functional
programming crowd. However, if we really intend to cater to them then we need to provide data structures that
are functional too, like lists and operations on them—unlike ES arrays, which are entirely imperative. Of course
users can implement those data structures themselves, if they have tail calls, but right now just adding tail calls
“for functional programming” seems like a half solution.
Finally, tail calls preclude the use of straightforward implementation techniques for procedure calls. To be sure
they are less limiting than generators, as one-shot continuations or longjumps are sufficient to handle tail calls in
a non-tail-calling implementation language, but implementations that want good-performance tail calls must
necessarily switch to a code generation technique.
This seems misguided. The user can implement functional data structures but not tail calls (without whole program transformation), so the later are much more valuable than the former. Furthermore, as a functional programmer I'm quite happy to use mutable data structures but I would certainly miss tail calls. Finally, every JS implementation is already shifting to code generation because straightforward implementation techniques are too slow for the existing idioms used in JS code.
The ES4 Wiki still indicates that tail calls are in, so perhaps they'll yet make it. For laughs you might want to look at the Ecmascript progress spreadsheet. Apple sure don't like change.