a big step towards std lib integration with async I/O

[andrewrk]

• zig test gains --test-evented-io parameter and gains the ability
  to seamlessly run async tests.
• std.ChildProcess opens its child process pipe with O_NONBLOCK when
  using evented I/O
• std.io.getStdErr() gives a File that is blocking even in evented
  I/O mode.
• Delete std.event.fs. The functionality is now merged into std.fs
  and async file system access (using a dedicated thread) is
  automatically handled.
• std.fs.File can be configured to specify whether its handle is
  expected to block, and whether that is OK to block even when in
  async I/O mode. This makes async I/O work correctly for e.g. the
  file system as well as network.
• std.fs.File has some deprecated functions removed.
• Missing readv,writev,pread,pwrite,preadv,pwritev functions are added
  to std.os and std.fs.File. They are all integrated with async
  I/O.
• std.fs.Watch is still bit rotted and needs to be audited in light
  of the new async/await syntax.
• std.io.OutStream integrates with async I/O
• linked list nodes in the std lib have default null values for
  prev and next.
• Windows async I/O integration is enabled for reading/writing file
  handles.
• Added std.os.mode_t. Integer sizes need to be audited.
• Fixed compiler segfaults with async fn call with tuple after integer parameter #4403 which was causing compiler to crash.

This is all working towards:

./zig test ../test/stage1/behavior.zig --test-evented-io

Which does not successfully build yet. I'd like to enable behavioral
tests and std lib tests with --test-evented-io in the test matrix in the
future, to prevent regressions.

[andrewrk]

I'm working on this case; will feel good about merging this after this works:

const std = @import("std");
const assert = std.debug.assert;

var global_frame: anyframe = undefined;

export fn entry() void {
    _ = async foo();
    resume global_frame;
}

const Foo = struct { x: i32 };

fn foo() anyerror!Foo {
    defer baz();
    return bar() catch |err| return err;
}

fn bar() anyerror!Foo {
    global_frame = @frame();
    suspend;
    return Foo{ .x = 99 };
}

fn baz() void {
    global_frame = @frame();
    suspend;
}

pub fn panic(msg: []const u8, stack_trace: ?*const std.builtin.StackTrace) noreturn {
    @breakpoint();
    unreachable;
}