support break in suspend blocks

[andrewrk]

Internally, await is a suspend block that reaches into the coroutine's frame, atomically modifies the awaiter pointer, and then based on the previous value of the awaiter pointer, might decide not to suspend after all.

We could expose this ability to zig programmers, like this:

suspend |p| {
    const prev_value = @atomicRmw(usize, &something, AtomicRmwOp.Xchg, something_else, AtomicOrder.SeqCst);
    if (prev_value == 0) {
        queue(p);
    } else {
        break;
    }
}

[andrewrk]

This feature can be used in a couple of interesting ways with a thread pool:

Switch the current function to running in another thread, and run another function in the current thread:

suspend |p| {
    threadPoolResume(p);
    anotherFunction();
    break;
}

Fork the current function, running it in 2 kernel threads simultaneously:

suspend |p| {
    threadPoolResume(p);
    break;
}

[andrewrk]

Also related is what to do when returning from a suspend block:

        suspend |p| {
            var ev = std.os.linux.epoll_event {
                .events = EPOLLIN|EPOLLET,
                .data = std.os.linux.epoll_data {
                    .ptr = @ptrToInt(p),
                },
            };
            try epoll_ctl(self.epollfd, EPOLL_CTL_ADD, fd, &ev);
        }

[andrewrk]

• labeled suspend blocks
• ability to break from labeled suspend block
• handle returning from suspend block (think about try carefully). it might already work correctly actually. return/try just cancels the suspend and then does a normal return/try. but let's add some test cases.
• update std.zig.parser to handle the new syntax
• documentation

[andrewrk]

Instead of breaking from a suspend block, you have to resume your own handle. It works fine - just make sure it's a tail call.