While that's true, I guarantee you that WOW incurs a similarly high overhead.
Thing is, 32->64-bit is an inherently difficult transition.
There are basically three schools of thought as to how to handle this:
1) 32-bit kernel, mixed 32/64-bit userland (Leopard)
Pros: Apps gain the benefits of 64-bit addressing. Excellent backwards compatibility (flawless, if done correctly). Excellent driver support. Allows 32/64 bit apps to run side-by-side.
Cons: Performance penalty (minimal, if done correctly -- but could be quite bad.) Doesn't solve the problem of 64-bit drivers -- just delays the need for it. (Then again, how many drivers actually need 64-bit addressing?) Harder to implement.
2) 64-bit kernel, both 32 and 64-bit userlands (32-bit chroot environment on 64-bit Linux boxes, for example)
Pros: Allows for "pure" 64-bit userland. Isolates "old code" from "new code." 64-bit kernel.
Cons: Isolates "old code" from "new code". 64-bit kernel (thus the chicken/egg driver problem.) More complex setup than other solutions. Less-than-perfect backwards compatibility (although still excellent.) Requires more disk space.
3) 64-bit kernel, 64-bit userland with 32-bit userland emulated (WOW64)
Pros: Near-perfect backwards compatibility (if done correctly.) 64-bit kernel. Often more transparent than #2.
Cons: Hack. Translation incurs a potentially significant performance overhead. More complex codebase. Processor-specific. Did I mention it's a hack?
There's no one "correct" way to do this. Each of the three solutions has its advantages, and each has its disadvantages.
Mac OS X is a fairly fast-moving OS to deal with. Yes, code is stable, but Apple doesn't have the religious dedication to backwards compatibility "at all costs" that MS does -- when something sucks, or is broken, Apple rips it out and replaces it. This means that old code doesn't tend to stick around for long unless it's well-written. This also means that it's easier make transitions (as it doesn't take as long for poorly-written code to be phased out.) For Apple, the 32-bit kernel and mixed userland is a good choice. Performance is acceptable (esp. since Leopard improved the kernel's high-load and SMP performance), and new apps can be written to take advantage of 64-bit addressing. The transition is a fairly gentle one, and all that's really needed is to wait for driver makers to start writing 64-bit drivers.
Windows is a slow-moving OS. Microsoft has a damn-near religious obsession with backwards compatibility. If something is broken, they'll go to extreme lengths to allow for the continued functioning apps that depend on the broken behavior (for examples, see the 16->32 bit transition, and the bizarre "virtual registry" scheme of Vista). This wins them some customers, but it also means that major transitions are a royal bitch. They had to make a sudden change, but still support old apps -- thus the only solution was the emulation/translation hack that is WOW64. This allowed them to move the OS to 64-bit in one go while still allowing old unmaintained apps to run unmodified -- but it did so at a cost (performance and a serious increase in complexity). They also can't abandon the broken parts of the API; in fact, they need to do even more work to support them (as they must now maintain said broken functionality in both Win32 _and_ WOW64.) This is going to make their life a bit more 'interesting' down the road, but is probably their best bet, given the circumstances.
Most of the software for Linux is open source, and a lot of it is actively maintained. Transitions of this nature are easy -- app developers just "tweak and recompile" (to use a familiar WWDC-esque) expression. The stuff that's not already 64-bit clean (or can't easily be made 64-bit clean) can be run in a 32-bit chrooted environment. There's not too much of this stuff barring a couple pieces of closed source software (ahem... Flash), so this is a workable solution. It's easy, doesn't require a lot of dirty hacks, and is a good interim solution until old code and closed source apps are either updated or replaced.
Each OS does things its own way for different reasons. The 32 -> 64 bit transition is a royal pain in the ass, and there's no perfect way to do it. Claiming that one OS does it in a better way than another, although possibly true from a technical perspective, requires that you overlook some 20-odd years of technical and business decisions.