fix(es/minifier): Mark all function params as potential property mutation (#7409)

**Description:**

This issue is more severe than I originally thought. It raises not in
array indexing, but in function calls and property mutation. We should
treat all function arguments as potentially be property mutated,
otherwise following example

```js
class A {
	a = 1

	toString() {
		return this.a
	}
}

const a = new A()

function foo(x) {
	x.a++
}

const b = a + 1

foo(a)

console.log(b)
```

would be error(It should log 2, but logs 3 after compress).

As the result, massive regressions is unavoidable, since some of these
optimizations may indeed cause error. Part of them can be mitigated with
following optimization -- allow inline of ident even if its original
value is mutated. Consider

```js
export function foo(x) {
   const y = x
   x.a = 1
   y.b = 2
}
```

If x is a primitive value, all mutations to its properties are ignored;
if x is a object, then y refers to the same object no matter what
mutation is performed.

And there's still room for more, currently following code
```js
export function foo(x) {
    const y = Math.floor(x);
    g(y);
}
```
But I'd rather do it in a separate PR.


**Related issue:**

 - Closes #7402.

Author: Austaras

crates/swc/tests/fixture/issues-5xxx/5112/output/index.js

@@ -1,8 +1,8 @@
 function c(r, n) {
-    let e = new Uint8Array(4 * r * r);
+    let e = new Uint8Array(4 * r * r), c = (r - n) / 2;
     return {
         e,
         s: Math.sqrt(1.25),
-        c: (r - n) / 2
+        c
     };
 }

crates/swc/tests/tsc-references/inferringClassMembersFromAssignments6.2.minified.js

@@ -6,8 +6,7 @@ function Foonly() {
     };
 }
 Foonly.prototype.mreal = function() {
-    var self = this;
-    self.y = 2;
+    this.y = 2;
 };
 var foo = new Foonly();
 foo.x, foo.y, foo.m();