I seem to be getting the answer as expect... but have I cleared Checkpoint 5, following Paul's core instructions? If not, why?

Looks good to me. I'd probably swap the sorted and filter operations so that you are sorting fewer items, but that's no biggie.

Could this same functionality be achieved without using any variables, without destroying the original input, and without a 'for...in' loop?

Not sure what you mean by "without destroying the original input". It's not destroyed, it's still there.

There's no good way to do it without using any variables if you want the "None of your numbers will win" message, but otherwise you could do this:

func winningNumberFinder(_ array: [Int]) {
    array
        .filter { $0.isMultiple(of: 2) }
        .sorted(by: <)
        .map { "\($0) is a winning number" }
        .forEach { print($0) }
}

And, really, in this case the map isn't even necessary, as you could just do:

.forEach { print("\($0) is a winning number") }

In his video, Paul specifically said "must use (isMultiple(of: _ ))" to filter. Is there a reason why I mustn't use the remainder operator?

Clarity and ease of reading. Also, % doesn't function as expected in certain cases involving negative numbers.

To quote from the Swift forum thread where the pitch for isMultiple(of:) was accepted:

It is substantially more fluent than its standard implementation of value % divisor == 0. Divisibility testing is the operation people actually want; the % operator is just the way they have to achieve it. % is rarely used outside of this idiom, and many programmers have no other reason to know it. It is not a familiar operator for new programmers especially: they will usually be comfortable with remainders in the context of division, but they aren't used to thinking about computing a remainder as a separate operation, and they certainly don't recognize % as a symbol for it. Even experienced programmers often mentally "pattern-match" this sort of expression to recognize it as a divisibility test instead of thinking through the arithmetic of it.

Encouraging the use of isMultiple(of:) (and !isMultiple(of:)) serves to counter bugs around negative remainders.

Next question...

Have I demonstrated a good/expected use of 'Closures' for Checkpoint 5?

Sure.

Have I chanied the functions as expected, and is this what Paul meant when he said, 'chain the functions'? Is there no other way to chain a function?

You're good. Although as I mentioned above I'd probably swap the sorted and filter functions.

Paul said, "use luckyNumbers.one, luckyNumbers.two, etc" to chain the functions. What did he mean by this?

When Paul said to use luckyNumbers.first { }.second { }, he also mentioned plugging in the actual function names instead of first and second.

I know my code can be better -- it could be shorter, less clustered, etc. Could you please show me how?

Your code looks okay. Changes I'd suggest:

1. winningNumbers should be a let instead of a var since you don't need it to change.
2. Swap sorted and filter.
3. You don't need to specify the closure body for sorted, you can just give it the < function.
4. Use isMultiple(of:).
5. Use string interpolation for generating the String in your map closure instead of concatenating two Strings.
6. Drop your chained functions onto separate line to make them easier to read.
7. Use a guard statement to catch an empty winningNumbers array.

func winningNumberFinder(_ array: [Int]) {
    let winningNumbers = array.filter { $0.isMultiple(of: 2) }
        .sorted(by: <)
        .map{ "\($0) is a Winning Number!" }

    guard !winningNumbers.isEmpty else {
        print("None of your numbers will win.")
        return
    }

    for i in winningNumbers {
        print(i)
    }
}