Issue:
Bug: refactor(euclid): transform enum types to include sub-variants of payment method types





Pull request description:
## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [ ] Bugfix
- [ ] New feature
- [x] Enhancement
- [ ] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description

This PR refactors the Euclid routing parameter transformation logic to **include sub-variants of payment method types** in the Decision Engine evaluation request.  

Key updates:
- Added logic to **convert `(payment_method_type, payment_method)` pairs** into a `DirValue` representation.
- Introduced `insert_dirvalue_param()` to map each `DirValue` variant into a corresponding routing parameter key.
- Enhanced `convert_backend_input_to_routing_eval` to insert these sub-variant parameters alongside existing routing parameters.
- This ensures richer context is sent to Euclid for more granular routing decisions.

## Outcomes

- Enables **finer-grained routing rules** based on payment method sub-types (e.g., `WalletType`, `CryptoType`, `GiftCardType`).
- Improves compatibility with dashboard-configured payment method rules in Euclid.
- Makes routing evaluation requests **more descriptive and precise**, improving match accuracy.

## Diff Hunk Explanation

### `crates/router/src/core/payments/routing/utils.rs`
- **Modified** `convert_backend_input_to_routing_eval`:
  - Added check for both `payment_method_type` and `payment_method` presence.
  - Converted them into a `DirValue` using `into_dir_value()`.
  - Inserted the resulting parameters into the evaluation request map.
- **Added** new helper `insert_dirvalue_param()`:
  - Matches on each `DirValue` variant and inserts it as a `ValueType::EnumVariant` with an appropriate key (e.g., `"wallet"`, `"crypto"`, `"bank_transfer"`).
  - Ignores unsupported or non-converging variants for now.
- **No changes** to external APIs or DB schema — purely internal parameter transformation refactor.

This refactor lays the groundwork for **sub-type aware routing** in Euclid without requiring external schema changes.


## 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)?
-->
Testing isn't required as this is just an enum mapping change.

## Checklist
<!-- Put an `x` in the boxes that apply -->

- [ ] I formatted the code `cargo +nightly fmt --all`
- [ ] I addressed lints thrown by `cargo clippy`
- [ ] I reviewed the submitted code
- [ ] I added unit tests for my changes where possible


Testing:

Testing isn't required as this is just an enum mapping change.

Patch:
diff --git a/crates/router/src/core/payments/routing/utils.rs b/crates/router/src/core/payments/routing/utils.rs
index d9d5ed1de26..f7eafcc28d1 100644
--- a/crates/router/src/core/payments/routing/utils.rs
+++ b/crates/router/src/core/payments/routing/utils.rs
@@ -18,7 +18,10 @@ use diesel_models::{enums, routing_algorithm};
 use error_stack::ResultExt;
 use euclid::{
     backend::BackendInput,
-    frontend::ast::{self},
+    frontend::{
+        ast::{self},
+        dir::{self, transformers::IntoDirValue},
+    },
 };
 #[cfg(all(feature = "v1", feature = "dynamic_routing"))]
 use external_services::grpc_client::dynamic_routing as ir_client;
@@ -593,6 +596,17 @@ pub fn convert_backend_input_to_routing_eval(
             "payment_method".to_string(),
             Some(ValueType::EnumVariant(pm.to_string())),
         );
+        if let Some(pmt) = input.payment_method.payment_method_type {
+            match (pmt, pm).into_dir_value() {
+                Ok(dv) => insert_dirvalue_param(&mut params, dv),
+                Err(e) => logger::debug!(
+                    ?e,
+                    ?pmt,
+                    ?pm,
+                    "decision_engine_euclid: into_dir_value failed; skipping subset param"
+                ),
+            }
+        }
     }
     if let Some(pmt) = input.payment_method.payment_method_type {
         params.insert(
@@ -647,6 +661,110 @@ pub fn convert_backend_input_to_routing_eval(
     })
 }
 
+// All the independent variants of payment method types, configured via dashboard
+fn insert_dirvalue_param(params: &mut HashMap<String, Option<ValueType>>, dv: dir::DirValue) {
+    match dv {
+        dir::DirValue::RewardType(v) => {
+            params.insert(
+                "reward".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::CardType(v) => {
+            params.insert(
+                "card".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::PayLaterType(v) => {
+            params.insert(
+                "pay_later".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::WalletType(v) => {
+            params.insert(
+                "wallet".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::VoucherType(v) => {
+            params.insert(
+                "voucher".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::BankRedirectType(v) => {
+            params.insert(
+                "bank_redirect".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::BankDebitType(v) => {
+            params.insert(
+                "bank_debit".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::BankTransferType(v) => {
+            params.insert(
+                "bank_transfer".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::RealTimePaymentType(v) => {
+            params.insert(
+                "real_time_payment".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::UpiType(v) => {
+            params.insert(
+                "upi".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::GiftCardType(v) => {
+            params.insert(
+                "gift_card".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::CardRedirectType(v) => {
+            params.insert(
+                "card_redirect".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::OpenBankingType(v) => {
+            params.insert(
+                "open_banking".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::MobilePaymentType(v) => {
+            params.insert(
+                "mobile_payment".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        dir::DirValue::CryptoType(v) => {
+            params.insert(
+                "crypto".to_string(),
+                Some(ValueType::EnumVariant(v.to_string())),
+            );
+        }
+        other => {
+            // all other values can be ignored for now as they don't converge with
+            // payment method type
+            logger::warn!(
+                ?other,
+                "decision_engine_euclid: unmapped dir::DirValue; add a mapping here"
+            );
+        }
+    }
+}
+
 #[derive(Debug, Clone, serde::Deserialize)]
 struct DeErrorResponse {
     code: String,