[X86] apply mulx optimization for two-wide mul instruction (mull, mulq) (#185127)

References: https://github.com/llvm/llvm-project/pull/184462

In the discussion for the linked PR, which removes unnecessary register
to register moves when one operand is in %rdx for mulx, the point was
brought up that this pattern also happens for mull and mulq.

The IR below:

```llvm
declare i32 @foo32()
declare i64 @foo64()

define i32 @mul32_no_implicit_copy(i32 %a0) {
  %a1 = call i32 @foo32()
  %a2 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %a0, i32 %a1)
  %a3 = extractvalue { i32, i1 } %a2, 0
  ret i32 %a3
}

define i64 @mul64_no_implicit_copy(i64 %a0) {
  %a1 = call i64 @foo64()
  %a2 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %a0, i64 %a1)
  %a3 = extractvalue { i64, i1 } %a2, 0
  ret i64 %a3
}
```

Generates this code on current HEAD:

```asm
mul32_no_implicit_copy:                 # @mul32_no_implicit_copy
        push    rbx
        mov     ebx, edi
        call    foo32@PLT
        mov     ecx, eax
        mov     eax, ebx
        mul     ecx
        pop     rbx
        ret
mul64_no_implicit_copy:                 # @mul64_no_implicit_copy
        push    rbx
        mov     rbx, rdi
        call    foo64@PLT
        mov     rcx, rax
        mov     rax, rbx
        mul     rcx
        pop     rbx
        ret
```

Where the register shuffling before the mul is the same pattern as for
mulx in the previous PR.

With this branch it generates this code now:

```asm
mul32_no_implicit_copy:
	pushq	%rbx
	movl	%edi, %ebx
	callq	foo32@PLT
	mull	%ebx
	popq	%rbx
	retq
mul64_no_implicit_copy:
	pushq	%rbx
	movq	%rdi, %rbx
	callq	foo64@PLT
	mulq	%rbx
	popq	%rbx
	retq
```