Sink parameters not copied at compile time
### Description

When an object is passed as a `sink` parameter during compile-time evaluation, it doesn't seem to be copied, even though it is used later. The same code works correctly, when not running at compile time.

Example for reproduction:
```nim
type O = object
    a: int

func mutate(o: sink O): O =
    o.a += 1
    o

static:
    let x = O(a: 1)
    let y = mutate(x)
    echo x
    echo y

block:
    let x = O(a: 1)
    let y = mutate(x)
    echo x
    echo y
```

### Nim Version

Nim Compiler Version 2.0.8 [Linux: amd64]
Compiled at 2024-09-08
Copyright (c) 2006-2023 by Andreas Rumpf

active boot switches: -d:release

### Current Output

```text
(a: 2)
(a: 2)
(a: 1)
(a: 2)
```


### Expected Output

```text
(a: 1)
(a: 2)
(a: 1)
(a: 2)
```


### Known Workarounds

Don't use compile-time evaluation. In my actual use case, I can replace two `const` declarations with `let` declarations to fix the issue. But this may not be possible in other use cases, where compile-time evaluation is actually required.

### Additional Information

Also checked with these versions, with the same results:
- ```
   Nim Compiler Version 2.1.99 [Linux: amd64]
   Compiled at 2024-09-24
   Copyright (c) 2006-2024 by Andreas Rumpf
   
   git hash: b9de2bb4f3864d264c3aeffdc630227448ad8c14
   active boot switches: -d:release
   ```
- ```
   Nim Compiler Version 1.6.21 [Linux: amd64]
   Compiled at 2024-07-10
   Copyright (c) 2006-2023 by Andreas Rumpf
   
   git hash: ec324ad0736c3e0cfa26b64d6631b15693633a6f
   active boot switches: -d:release
   ```
- ```
   Nim Compiler Version 1.0.0 [Linux: amd64]
   Compiled at 2019-09-23
   Copyright (c) 2006-2019 by Andreas Rumpf

   active boot switches: -d:release
   ```
With this version:
```
Nim Compiler Version 0.20.2 [Linux: amd64]
Compiled at 2019-07-17
Copyright (c) 2006-2019 by Andreas Rumpf

active boot switches: -d:release
```
the compiler produces an error:
```
/path/to/bug.nim(5, 9) Error: type mismatch: got <int, int literal(1)>
but expected one of:
proc `+=`[T: SomeInteger](x: var T; y: T)
  for a 'var' type a variable needs to be passed, but 'o.a' is immutable
proc `+=`[T: enum | bool](x: var T; y: T)
  first type mismatch at position: 1
  required type: var T: enum or bool
  but expression 'o.a' is of type: int
  for a 'var' type a variable needs to be passed, but 'o.a' is immutable
proc `+=`[T: float | float32 | float64](x: var T; y: T)
  first type mismatch at position: 1
  required type: var T: float or float32 or float64
  but expression 'o.a' is of type: int
  for a 'var' type a variable needs to be passed, but 'o.a' is immutable

expression: o.a += 1
```