Make calls to sync wait (in real time) before sending sync event:

A typical pattern for using `sync` and `wait` is as follows:

    def clock
      sync :tick
      sleep sample_duration :loop_breakbeat
    end


    def beat
      wait :tick
      sample :loop_breakbeat
      sleep sample_duration :loop_breakbeat
    end

    in_thread{loop{clock}}
    loop{beat}

The issue with this was that the beat fn might miss a sync message every 
so often. This is because it might loop round to its wait call just slightly
after the sync message it wanted to catch was released. This in turn is 
because both the clock and beat messages are sleeping for the same duration
which means that we have a race condition!

By forcing the sync message to be behind in real time (by using a standard
Kernel.sleep and not advancing the virtual clock) we can decrease the 
probability that the beat loop misses a :tick message.

The trade-off here is that the threads which wait now have slightly less
real time to perform their computation.