Implementing the WAITAOF functionality requested in issue #10505, which would allow the user to block until a specified number of Redises have fsynced all previous write commands to the AOF.

Syntax: WAITAOF <num_local> <num_replicas> <timeout>
Response: Array containing two elements: num_local, num_replicas
num_local is always either 0 or 1 representing the local AOF on the master.
num_replicas is the number of replicas that acknowledged the a replication
offset of the last write being fsynced to the AOF.

Returns an error when called on replicas, or when called with non-zero
num_local on a master with AOF disabled, in all other cases the response
just contains number of fsync copies.

Main changes:

• Added code to keep track of replication offsets that are confirmed to have been fsynced to disk.
• Keep advancing master_repl_offset even when replication is disabled (and there's no replication backlog, only if there's an AOF enabled).
  This way we can use this command and it's mechanisms even when replication is disabled.
• Extend REPLCONF ACK to REPLCONF ACK <ofs> FACK <ofs>, the FACK will be appended only if there's an AOF on the replica, and already ignored on old masters (thus backwards compatible)
• WAIT now no longer wait for the replication offset after your last command, but rather the replication offset after your last write (or read command that caused propagation, e.g. lazy expiry).

Unrelated changes:

• WAIT command respects CLIENT_DENY_BLOCKING (not just CLIENT_MULTI)

Implementation details:

• Add an atomic var named fsynced_reploff_pending that's updated (usually by the bio thread) and later copied to the main fsynced_reploff variable (only if the AOF base file exists).
  I.e. during the initial AOF rewrite it will not be used as the fsynced offset since the AOF base is still missing.
• Replace close+fsync bio job with new BIO_CLOSE_AOF (AOF specific) job that will also update fsync offset the field.
• Handle all AOF jobs (BIO_CLOSE_AOF, BIO_AOF_FSYNC) in the same bio
  worker thread, to impose ordering on their execution. This solves a
  race condition where a job could set fsynced_reploff_pending to a higher
  value than another pending fsync job, resulting in indicating an offset
  for which parts of the data have not yet actually been fsynced.
  Imposing an ordering on the jobs guarantees that fsync jobs are executed
  in increasing order of replication offset.
• Drain bio jobs when switching appendfsync to "always"
  This should prevent a write race between updates to fsynced_reploff_pending
  in the main thread (flushAppendOnlyFile when set to ALWAYS fsync), and
  those done in the bio thread.
• Drain the pending fsync when starting over a new AOF to avoid race conditions
  with the previous AOF offsets overriding the new one (e.g. after switching to replicate from a new master).
• Make sure to update the fsynced offset at the end of the initial AOF rewrite.
  a must in case there are no additional writes that trigger a periodic fsync, specifically for a replica that does a full sync.

Limitations:
It is possible to write a module and a Lua script that propagate to the AOF and doesn't
propagate to the replication stream. see REDISMODULE_ARGV_NO_REPLICAS and luaRedisSetReplCommand.
These features are incompatible with the WAITAOF command, and can result in two bad cases.
The scenario is that the user executes command that only propagates to AOF, and then immediately
issues a WAITAOF, and there's no further writes on the replication stream after that.

1. if the the last thing that happened on the replication stream is a PING (which increased the replication offset but won't trigger an fsync on the replica), then the client would hang forever (will wait for an fack that the replica will never send sine it doesn't trigger any fsyncs).
2. if the last thing that happened is a write command that got propagated properly, then WAITAOF will be released immediately, without waiting for an fsync (since the offset didn't change)

Refactoring:

• Plumbing to allow bio worker to handle multiple job types
  This introduces infrastructure necessary to allow BIO workers to
  not have a 1-1 mapping of worker to job-type. This allows in the
  future to assign multiple job types to a single worker, either as
  a performance/resource optimization, or as a way of enforcing
  ordering between specific classes of jobs.

Discussion:
[Note currently this PR implements the most explicit approach of the options presented blow]

In its most general form, the command can be used to wait for fsync by replicas, by the master (or only Redis if replication is not used), or some combination of the above. A few use-cases I can think of:

1. I have no replication, and wish to wait for all of my previous writes to be persisted to disk before I continue.
2. I have a master and n replicas. I wish to wait for at least m of those replicas to persist my writes to disk before I continue.
3. I have a master and n replicas. I wish to wait until at least m Redises (including both master and replicas) have persisted my writes to disk before I continue.

The simplest approach would be to extend the existing WAIT command with an optional AOF keyword:

WAIT AOF <num> <timeout>

In which case we need to define whether <num> includes the master or not. If it does, use-cases 1 and 3 are covered, but use-case 2—which would probably be a pretty common one—is impossible; If it does not, 2 is supported but 1 and 3 are not. This could be extended by giving "0" the special meaning of "wait for current Redis only" to enable use-case 1, but this might be somewhat surprising semantics.

Another option that crossed my mind is to use positive/negative numbers for the different meanings. e.g.: "-5" means "wait for any 5 Redises" while "5" means "wait for 5 replicas." This is simple and supports all 3 use-cases above, but might not be intuitive or particularly easy to remember.

Yet another possibility is of course to split this functionality into a separate command entirely, in which case we need to define the arguments and semantics of that new command.

Todo:

• make a redis-doc PR: Add documentation for new WAITAOF command, and update commands.json redis-doc#2359