Fix redis transaction when traffic is mirrored

[asheryerm]

Commit Message: Fix redis transaction when traffic is mirrored

Additional Description:

When envoy is configured to mirror Redis traffic, using transactions (MULTI) would not work well, possibly leading to a crash. This PR fixes this issue by making the following changes:

1. I have defined MULTI, EXEC, and DISCARD as write commands, so they will be mirrored even when read commands are excluded from mirroring.
2. A dedicated connection for the transaction is opened for each redis server that receives mirrored commands, the same way a dedicated connection is opened to the main redis server.

This PR fixes the following issue: #26342

Risk Level: Low
Testing: Integration tests and local tests. Reproduced the problem by using the same configuration used in the open issue.
Docs Changes: None
Release Notes: None
Platform Specific Features: None
[Optional Runtime guard:]
[Optional Fixes #Issue] #26342
[Optional Fixes commit #PR or SHA]
[Optional Deprecated:]
[Optional API Considerations:]

[ravenblackx]

Trailing underscore on member variables.

Would be nice to have some commentary on this too, since it's a bit of a weird mutable value. Is there definitely no way this can change while operations are in flight? Is this whole class effectively single-threaded in everything it does?

I'm not familiar with this code, but I would expect

mirror_policy->upstream()->makeRequest(key, ConnPool::RespVariant(incoming_request),
                                               null_pool_callbacks, transaction);

to be something where stuff happens asynchronously, such that the loop that makes this call for each mirror instance might be doing something racy once this gets out of the test environment.

[asheryerm]

The requests themselves are always sent in the same order, this can be seen in the code. First you send the request to the main server:

  transaction.current_client_idx_ = 0;
  auto handler = route->upstream()->makeRequest(key, ConnPool::RespVariant(incoming_request),
                                                callbacks, transaction);

And then to each of the mirror servers in the order in which they appear in the vector route->mirrorPolicies() at startup:

  if (handler) {
    for (auto& mirror_policy : route->mirrorPolicies()) {
      transaction.current_client_idx++;
      if (mirror_policy->shouldMirror(command)) {
        mirror_policy->upstream()->makeRequest(key, ConnPool::RespVariant(incoming_request),
                                               null_pool_callbacks, transaction);
      }
    }
  }

The replies may be received out of order but that's ok because each reply is mapped to the proper client connection. For mirrored connections we ignore the replies in any case. This is done by providing null_pool_callbacks as the callbacks parameter. So only the reply to the main connection is not discarded.

[asheryerm]

I've added the underscore + a comment on the variable name

[ravenblackx]

Got a DCO problem now because the commit wasn't signed.

[asheryerm]

Unfortunately Signing off previous commits is complicated since I have a merge commit. Closing this PR and opening a new PR: #28244

[asheryerm]

Opened a new PR with commits signed properly: #28244