The idea of this is to ensure that we won't have a delay when computing the time at which ```hwtimer_spin()``` should quit.

Let's imagine the function is called with a short delay (for example: 6 cycle, which means some 180µs with a classical clock at 32 KHz); this is a common case, especially since ```hwtimer_wait()``` will handle all short wait delay to ```hwtimer_spin()```.
Suppose an interruption occurs during this computation: the delay that was given as parameter to ```hwtimer_spin()```will then add up to that extra time taken by the other task; while the function should on the contrary subtract it from the initial delay, and even return immediately if the initial delay has entirely elapsed.

This modification should ensure that the target time is correctly computed, and thus that ```hwtimer_spin()``` won't block the calling thread for an excessive amount of time.
Since the computation itself is bound to be a quick operation, reading one or two hardware registers (counters) and performing an addition, the interruptions aren't disabled for a significative amount of time.

Do you see a drawback with this modification?