In the case of an announcement of a general '64 bit support,' the meaning is simply that a larger memory space can be used. Pointers (memory addresses) are larger and can thus address more slots in memory. The size of the data being accessed is otherwise not modified by this; an integer is still 32 bits, a float is still 32 bits, a short is still 16, and a char is 8. Switching to 64 bit doesn't change this; just that you can use as much memory as your 64 bit OS allows. 2^32 = 4,294,967,296; which is roughly where the 4GB memory limit of a 32 bit application comes from.
In the other case, if it was an announcement about using higher precision numbers for positions, physics, or something along those lines.... (And I don't think it was, as last I heard that was still something being discussed as a possibility, rather than something which was set in stone; though that's not my specialty, so it may have changed recently) ... In that case, it would actually involve larger data types, but only in specific subsystems. There is really no case in which we would simply increase the sizes on our datatypes across the board. As you mentioned, this would slow things down (and not just on the GPU either). However, there are certain cases in which we might want more precision. In these cases, it largely comes down to a question of a precision increase vs the cost of a workaround. Some great examples of such can be found in the Kerbal Space Program dev logs, in their battles against the Deep Space Kraken:
http://forum.kerbalspaceprogram.com/entries/12-Krakensbane
When implementing these sorts of fixes, it is preferable to keep the changes as isolated as possible in order to avoid unnecessary code rewrites, performance hits, or memory consumption. In the rendering, you generally don't need to worry about precision in the subsystems you might want to increase. If you had a ship and a camera in a space represented by 64 bit values, you can pre-transform everything into a local camera-relative space, then send that to the GPU as a space represented by 32 bit values without losing any useful precision. You lose precision far from the camera, but that precision doesn't actually make a difference to the rendering. It's actually quite common to convert down even smaller than that in cases where you don't need a full 32 bits of precision.
Hope that clears things up a bit!
