perf: avoid redundant validation in copy() and __iter__ (#193)

BaseInstr.copy() previously reconstructed instructions via __init__,
triggering the full _set → _check_arg validation chain on every copy
even though the source instruction is already known to be valid.
Replace with object.__new__ + direct slot assignment to bypass
validation entirely.

_BaseBytecodeList.__iter__ ran _check_instr on every yielded item, but
Bytecode.__iter__ (which calls this via super()) was already doing the
same check — a redundant double-validation on every iteration.

Profiling shows:
- Instr._check_arg own time: 7.85% → 3.13% (−4.72%)
- BaseInstr._set own time:   2.57% → 1.37% (−1.20%)
- _BaseBytecodeList.__iter__ eliminated (was 2.18%)

Author: P403n1x87

src/bytecode/bytecode.py

@@ -164,12 +164,6 @@ def legalize(self) -> None:
         for i in reversed(lineno_pos):
             del self[i]
 
-    def __iter__(self) -> Iterator[U]:
-        instructions = super().__iter__()
-        for instr in instructions:
-            self._check_instr(instr)
-            yield instr
-
     def _check_instr(self, instr):
         raise NotImplementedError()
 

src/bytecode/instr.py

@@ -812,7 +812,12 @@ def pre_and_post_stack_effect(self, jump: Optional[bool] = None) -> tuple[int, i
             return (_effect, 0)
 
     def copy(self: T) -> T:
-        return self.__class__(self._name, self._arg, location=self._location)
+        new = object.__new__(self.__class__)
+        new._name = self._name
+        new._opcode = self._opcode
+        new._arg = self._arg
+        new._location = self._location
+        return new
 
     def has_jump(self) -> bool:
         return self._has_jump(self._opcode)