Add case-sensitivity handling to multi-object download operations

[hssyoo]

Addresses #9596

Problem

Case conflicts can happen if the following conditions are met:

• Command is 1 of sync, cp, mv.
• Command is a directory operation. sync is always a directory operation and cp and mv with the --recursive flag becomes a directory operation.
• Command is a S3 -> local operation.

There are 2 case conflict scenarios we need to address:

1. Source object keys exist that differ only by case, eg a.txt and A.txt. When these are downloaded onto a case-insensitive filesystem, the last to write wins.
2. Source object key and a local file differ only by case. If a.txt is downloaded from S3, it will overwrite the local A.txt file.

Requirements

Detecting case conflicts requires 2 approaches:

1. We need a way of tracking the (lower-cased) keys of objects submitted for download. So if we start downloading a.txt and then we see the next to download is A.txt, we need to be able to detect the case conflict even if a.txt hasn't finished downloading yet.
2. We need knowledge of the local files so that we avoid overwriting files that differ only by case.

Handling case conflicts automatically is difficult because it's impossible to know what the user expectations are. We can't start throwing errors because we'll break customers. So we'll warn by default when a case conflict is detected and let them configure behavior:

• error for throwing errors
• warn for emitting warnings (default)
• skip for skipping an object
• ignore for doing nothing (current behavior)

Solution

sync always has knowledge of local files, so it's more straightforward. Just create a new sync strategy that detects case conflicts and handles them. Instead of writing new filesystem logic for recursive cp and mv, we'll transform their instructions to mimic a sync command if we determine that case conflicts need to be handled. There's not much extra hit in terms of performance since it's just local filesystem API calls.

To keep track of objects submitted for downloads, we'll keep a simple in-memory hash set that tracks lower-cased forms of object keys. If a.txt has been submitted for download and we try A.txt, it'll see that the lower-cased form is in the set and handle the case conflict.

To avoid the set growing large and consuming extra memory, the solution also implements a subscriber that will discard the key from the set once the download finishes. The key can be removed from the set at this point because it now exists in the filesystem. So when we attempt to download subsequent objects with case conflicts, it'll simply check if it exists locally.

Caveats

S3 Express can't be supported because it doesn't return objects in lexicographical order. We need ordered keys for sync.

[kdaily]

LGTM besides a nit in the changelog entry!