The `_dispatch_sema4_t` type is a pointer to the handle of the
semaphore, so we need to indirect through the pointer before using it.
This site was incorrectly using it directly.

This sets up the event loop for Windows to run and schedule timers.
This allows us to start running some of the timer sources.

This cleans up the __LP64__ usage to allow libdispatch to work correctly
on LLP64 targets (like Windows x64).

Linux, FreeBSD already define DISPATCH_COCOA_COMPAT, and Windows was
defining that in a couple of places in an unstructured haphazard manner.
Define it similarly and clean up the other sites.

FlsAlloc returns FLS_OUT_OF_INDEXES in an error scenario, everything
else is a valid result.  Correct the assertion.

The NT time representation uses 1/1/1601 as epoch as opposed to Unix
which uses 1/1/1970.  Account for the offset in the calculation.  This
corrects the calculation of now.

This is needed for XCTest to run its test suite.

Use the `GetSystemTimePreciseAsFileTime` rather than
`GetSystemTimeAsFileTime` as we may otherwise get a cached value from
the last context switch.

Ideally we would do the lazy semaphore approach that Mach does.
Unfortunately, the queue wasn't getting drained as in that case.  A
follow up should investigate and fix the lazy allocation.

This was being re-implemented in CF by means of a macro.  Just expose
the function instead.

The dispatch_cascade test is very slow on Windows right now (often taking 4-5
minutes to execute on my machine and sometimes locking it up entirely) because
contention is not being handled correctly.

`_dispatch_contention_usleep()` is expected to put the thread to sleep, but on
Windows it spins on `QueryPerformanceCounter()`. This is causing a huge amount
of starvation in the dispatch_cascade test. Implement it using `Sleep()`, and
accordingly adjust `DISPATCH_CONTENTION_USLEEP_START` to be 1ms on Windows.

Additionally, `_dispatch_contention_spins()` is currently implemented using the
`rand_s()` function. This is slow (and experimentally seems to be slower than
not randomizing the spin count at all!) because `rand_s()` guarantees
cryptographic security, which is unnecessary for dispatch's use case. Replace it
with a basic linear congruential generator (from K&R) since there isn't any
other `rand_r()` equivalent. Based on the average wall clock times reported by
bsdtestharness, this is around 35% faster on my PC (i7-8700K).

These changes bring the runtime of the dispatch_cascade test down to around 1-2s
at most for me. (It's even faster than this if stdout isn't a console window
because that slows down the histogram display.)

The 1121 merge introduced additional usage of sys/queue.h.  Flesh out
the shims header further to repair the build on Windows.

The `dsema_value` field was marked as long which is incorrect for LLP64
environments.  Update the type to `intptr_t` which is the portable type
for this value.

This should use `QueryUnbiasedInterruptTime`  `QueryPerformanceCounter`
is roughly in units of of TSC frequency.  We would need to use
`QueryPerformanceFrequency` to convert that into nanoseconds.
Additionally, `QueryPerformanceCounter` includes time spent during
suspend, which is not what is desired.  Switch to
`QueryUnbiasedInterruptTime` to get something close to `CLOCK_MONOTONIC`
on Linux.

Windows does not support 128-bit division, disable the support for now.
One option is to statically link compiler-rt to provide `__udivti3`.

This addresses the updates that were not applied to the Windows port but
were applied to the Linux port and the macOS port.

PR apple#453 provides an initial implementation for timer support on Windows. Support
building and running the `DISPATCH_SOURCE_TYPE_TIMER` tests so we can easily
verify that timers work correctly.

These tests should pass on Windows with this and apple#453 applied:

- dispatch_drift
- dispatch_suspend_timer
- dispatch_timer
- dispatch_timer_bit31
- dispatch_timer_bit63
- dispatch_timer_set_time
- dispatch_timer_short
- dispatch_timer_timeout