Well I get your point, even though I disagree. For a game developer the problems with diverging calculations due to floating point differences only come in some particular edge cases - like division/miltiplication by 0 when it's not 0 (or in general scaling),
some trigonometry (like tg), collisions that don't happen even though bodies are "touching", lines that seem parallel but are not - stuff like that. These edge cases might not be such a big deal really - for example a bullet just grazing a target instead of
hitting it is not a big deal. Some tunneling could be ok...
However there is still a problem with the integrator which is iterative and also run in multiples over time and it already has issues since it is just an approximation. See for example http://en.wikipedia.org/wiki/Flying_ice_cube
In our case joints might be the issue rather than bodies. I think by loosing precision you might get your simulations to agree more but you risk them becoming inaccurate and that can have consequences like bodies getting stuck into each other or joints becoming
unstable. In other words you might reach situations from which the engine cannot recover and that worries me.
Since you have to synchronize anyway sooner or later (like every 5s maximum) why do all that work for little benefit. If your model is very complex then even on one machine and without networking semi-implicit Euler might already be quite innacurate let
alone you tamper with it or "adjust" it with brute force post-time step. If your model is simple - then the integrator is already quite accurate anyways regardless of precision if the latter is within sensible limits. In other words even if you used a perfect
integrator (or at least a fourth-order one like RK4) you would gain no benefits losing speed. Consequently the error in floating pont math between machine with different architectures would not influence anything that much.
If, instead, your model is in-between in terms of complexity then you can certainly try out some adjustments but corner cases might rear their ugly heads at the most unfortunate moments.
At the end of the day we should really ask what is that makes it so difficult to synchronize across a network. I would argue that *by far* this is the inconsistencies of roundtrip transmission times that far outweigh anything else in scale. The simple fact
that you can lose a whole packet of information (and TCP is just a band-aid) can have a huge impact. Furthermore since we have no control over the Internet you would have to deal with that problem anyways in some manner...