Add delay and once

`delay` takes a time in ms and a signal and executes events from the signal after a delay of ms

`once` takes a signal and executes the first event from that signal and then stops
This comes with the caveat that I'm not an FRP expert (but I still feel strongly that we should take the time to make sure we're picking the right abstraction).

The signals implemented so far never "unsubscribe" and this simplifies the implementation, and makes analysis simpler. You could implement something like `once` using:

```
die :: forall a. Signal a -> Signal Boolean
die = foldp (\_ _ -> false) true
```

which just switches from `true` to `false` after the first change in the signal. Then:

```
once s = Tuple <$> s <*> die s
```

will give you an (infinite) signal of tuples whose second component tells you whether or not you're on the first update or not. (not tested)

This has the disadvantage that the signal is still in memory long after it fires its only update, but the advantage that it is simpler to reason about (IMO). This is the same sort of reason why we don't want monadic signals - they introduce dynamic behavior which prevents static analysis and tooling like Elm's interactive debugger.