是否有可能同时进行可变绑定和解构？

问：

下面的代码按预期工作（演示），但这需要两个嵌套，我只想用一个替换。match {}

#![allow(unused)]
use std::collections::hash_map::HashMap;

#[derive(Debug, Clone)]
struct NormalTransaction(f64);

//  only normal transaction can be disputed.. BY DESIGN
#[derive(Debug, Clone)]
struct DisputeTransaction(NormalTransaction);

#[derive(Debug, Clone)]
enum Transaction {
    Normal(NormalTransaction),
    Dispute(DisputeTransaction),
}

fn main() {
    let mut m = HashMap::new();
    m.insert(1, Transaction::Normal(NormalTransaction(100.0)));
    
    println!("before: {:#?}", m);
    
    match m.get_mut(&1) {
        Some(t) => match t {
            Transaction::Normal(normal) => {
                *t = Transaction::Dispute(DisputeTransaction(normal.clone()));
            }   
            _ => {}, // NA
        }
        _ => {}, // NA
    }
    
    println!("after: {:#?}", m);
}

仅将两者替换为一个，如下所示：match{}

    match m.get_mut(&1) {
        Some(t @ Transaction::Normal(normal)) => {
            *t = Transaction::Dispute(DisputeTransaction(normal.clone()));
        }
        _ => {}, // NA
    }

但它不起作用，说（演示）：

error: borrow of moved value
  --> src/main.rs:24:14
   |
24 |         Some(t @ Transaction::Normal(normal)) => {
   |              -^^^^^^^^^^^^^^^^^^^^^^^------^
   |              |                       |
   |              |                       value borrowed here after move
   |              value moved into `t` here
   |              move occurs because `t` has type `&mut Transaction` which does not implement the `Copy` trait

error[E0382]: borrow of moved value
  --> src/main.rs:24:38
   |
24 |         Some(t @ Transaction::Normal(normal)) => {
   |              ------------------------^^^^^^-
   |              |                       |
   |              |                       value borrowed here after move
   |              value moved here
   |
   = note: move occurs because value has type `&mut Transaction`, which does not implement the `Copy` trait
help: borrow this field in the pattern to avoid moving the value
   |
24 |         Some(ref t @ Transaction::Normal(normal)) => {
   |              +++

是否可以在单个匹配情况下进行可变绑定和解构？