Issue:
Bug: [REFACTOR] The `Drop` implementation on `RedisConnectionPool` seems unnecessary



### Description

I'll keep this issue as a source of documentation and decisions taken regarding the graceful shutdown of Redis connections.

When I was working on #1743, I noticed that the `Drop` implementation on `RedisConnectionPool` caused panics when tests were being run.

https://github.com/juspay/hyperswitch/blob/1ab4226c780e9205785f012fd1c48c7a4bafb48f/crates/redis_interface/src/lib.rs#L197-L203

When I went down the rabbit hole of identifying possible solutions to it, I found that none of the log messages within [`close_connections()`](https://github.com/juspay/hyperswitch/blob/1ab4226c780e9205785f012fd1c48c7a4bafb48f/crates/redis_interface/src/lib.rs#L157-L179) were ever printed. To address this, I temporarily added a `std::mem::forget(_guard)` line in `router/src/bin/router.rs` so that the logs would be available. 

This brought out the fact that all attempts by us to close Redis connections (the connection pool, publisher client and subscriber client) were failing with the following warning:

```text
Fatal error sending QUIT command to router. Client may be stopped or not yet initialized.
```

When I attached the debugger, set a debugger breakpoint at the first line of the `Drop` implementation and listed Redis clients using the `redis-cli` tool, there were no Redis clients arising from the application in the list, and the warning was indeed correct. 

It seems that Redis connections are being closed before even the `Drop` implementation has been entered, and I'm unable to explain why. I couldn't find anything relevant in the `fred` codebase either. I was able to reproduce this with a Redis cluster set up using Docker Compose. 

Pull request description:
## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [ ] Bugfix
- [ ] New feature
- [ ] Enhancement
- [x] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description
<!-- Describe your changes in detail -->
This PR drops the `Drop` implementation (pun intended) on `RedisConnectionPool`.

## Motivation and Context
<!--
Why is this change required? What problem does it solve?
If it fixes an open issue, please link to the issue here.

If you don't have an issue, we'd recommend starting with one first so the PR
can focus on the implementation (unless its an obvious bug or documentation fix
that will have little conversation).
-->
Fixes #1782.

## How did you test it?
<!--
Did you write an integration/unit/API test to verify the code changes?
Or did you test this change manually (provide relevant screenshots)?
-->
Locally, with both a standalone Redis instance and a Redis cluster setup with Docker Compose.

## Checklist
<!-- Put an `x` in the boxes that apply -->

- [x] I formatted the code `cargo +nightly fmt --all`
- [x] I addressed lints thrown by `cargo clippy`
- [x] I reviewed submitted code
- [ ] I added unit tests for my changes where possible
- [ ] I added a [CHANGELOG](/CHANGELOG.md) entry if applicable


Testing:

Locally, with both a standalone Redis instance and a Redis cluster setup with Docker Compose.

Patch:
diff --git a/crates/redis_interface/src/lib.rs b/crates/redis_interface/src/lib.rs
index b06cc6c274f..3df54d5dc8d 100644
--- a/crates/redis_interface/src/lib.rs
+++ b/crates/redis_interface/src/lib.rs
@@ -33,7 +33,6 @@ pub use self::{commands::*, types::*};
 pub struct RedisConnectionPool {
     pub pool: fred::pool::RedisPool,
     config: RedisConfig,
-    join_handles: Vec<fred::types::ConnectHandle>,
     pub subscriber: SubscriberClient,
     pub publisher: RedisClient,
     pub is_redis_available: Arc<atomic::AtomicBool>,
@@ -136,7 +135,6 @@ impl RedisConnectionPool {
             .into_report()
             .change_context(errors::RedisError::RedisConnectionError)?;
 
-        let join_handles = pool.connect();
         pool.wait_for_connect()
             .await
             .into_report()
@@ -147,37 +145,12 @@ impl RedisConnectionPool {
         Ok(Self {
             pool,
             config,
-            join_handles,
             is_redis_available: Arc::new(atomic::AtomicBool::new(true)),
             subscriber,
             publisher,
         })
     }
 
-    pub async fn close_connections(&mut self) {
-        self.pool.quit_pool().await;
-
-        self.publisher
-            .quit()
-            .await
-            .map_err(|err| logger::error!(redis_quit_err=?err))
-            .ok();
-
-        self.subscriber
-            .quit()
-            .await
-            .map_err(|err| logger::error!(redis_quit_err=?err))
-            .ok();
-
-        for handle in self.join_handles.drain(..) {
-            match handle.await {
-                Ok(Ok(_)) => (),
-                Ok(Err(error)) => logger::error!(%error),
-                Err(error) => logger::error!(%error),
-            };
-        }
-    }
-
     pub async fn on_error(&self, tx: tokio::sync::oneshot::Sender<()>) {
         while let Ok(redis_error) = self.pool.on_error().recv().await {
             logger::error!(?redis_error, "Redis protocol or connection error");
@@ -194,14 +167,6 @@ impl RedisConnectionPool {
     }
 }
 
-impl Drop for RedisConnectionPool {
-    // safety: panics when invoked without a current tokio runtime
-    fn drop(&mut self) {
-        let rt = tokio::runtime::Handle::current();
-        rt.block_on(self.close_connections())
-    }
-}
-
 struct RedisConfig {
     default_ttl: u32,
     default_stream_read_count: u64,
diff --git a/crates/router/src/connection.rs b/crates/router/src/connection.rs
index a84039a9035..a5d436d0d8e 100644
--- a/crates/router/src/connection.rs
+++ b/crates/router/src/connection.rs
@@ -10,7 +10,6 @@ use crate::{configs::settings::Database, errors};
 pub type PgPool = bb8::Pool<async_bb8_diesel::ConnectionManager<PgConnection>>;
 
 pub type PgPooledConn = async_bb8_diesel::Connection<PgConnection>;
-pub type RedisPool = std::sync::Arc<redis_interface::RedisConnectionPool>;
 
 #[derive(Debug)]
 struct TestTransaction;