Further optimize the code, assuming that the invariant holds

this invariant is: the report keys are unique (any nonzero entry appears
at most once) and compact (all nonzero entries are first).

A benchmark loop measures how long add/remove report take depending
on the number of other keys pressed:
```
    kbd = Keyboard(usb_hid.devices)

    t0 = ticks_ms()
    for _ in range(1000):
        kbd._add_keycode_to_report(K.A)
        kbd._remove_keycode_from_report(K.A)
    t1 = ticks_ms()
    print(f"Press release key time {ticks_diff(t1,t0)}us/call")
    kbd = Keyboard(usb_hid.devices)

    t0 = ticks_ms()
    for _ in range(1000):
        kbd._add_keycode_to_report(K.A)
        kbd._remove_keycode_from_report(K.A)
    t1 = ticks_ms()
    print(f"Press release key time {ticks_diff(t1,t0)}us/call")

    for k in range(K.ONE, K.SIX):
        kbd._add_keycode_to_report(k)

        t0 = ticks_ms()
        for _ in range(1000):
            kbd._add_keycode_to_report(K.A)
            kbd._remove_keycode_from_report(K.A)
        t1 = ticks_ms()
        print(f"Press release key time {ticks_diff(t1,t0)}us/call")

    kbd.release_all()
```

Timings were done on a KB2040 with 8.0.0-beta.

| Test | Before | After |
| Empty | 238 | 158 |
| 1 | 246 | 188 |
| 2 | 255 | 219 |
| 3 | 266 | 249 |
| 4 | 274 | 280 |
| 5 | 283 | 301 |

So in the usual case (fewer than 4 non-modifier keys pressed) this
slightly improves performance, but when the report is full (even if
it doesn't overflow) performance decreases, albeit by just 18us. Compared
to the 8ms time to send a report or the default 20ms between polling
a keypad.KeyMatrix this is minor.

Author: jepler

adafruit_hid/keyboard.py

@@ -134,18 +134,15 @@ def _add_keycode_to_report(self, keycode: int) -> None:
             self.report_modifier[0] |= modifier
         else:
             # Don't press twice.
-            # (I'd like to use 'not in self.report_keys' here, but that's not implemented.)
-            free_slot = None
             for i in range(_MAX_KEYPRESSES):
-                if free_slot is None and self.report_keys[i] == 0:
-                    free_slot = i
+                if self.report_keys[i] == 0:
+                    # Put keycode in first empty slot. Since the report_keys
+                    # are compact and unique, this is not a repeated key
+                    self.report_keys[i] = keycode
+                    return
                 if self.report_keys[i] == keycode:
                     # Already pressed.
                     return
-            # Put keycode in first empty slot.
-            if free_slot is not None:
-                self.report_keys[free_slot] = keycode
-                return
             # All slots are filled. Shuffle down and reuse last slot
             for i in range(_MAX_KEYPRESSES - 1):
                 self.report_keys[i] = self.report_keys[i + 1]
@@ -158,16 +155,19 @@ def _remove_keycode_from_report(self, keycode: int) -> None:
             # Turn off the bit for this modifier.
             self.report_modifier[0] &= ~modifier
         else:
-            # Clear any matching slots and move remaining keys down
+            # Clear the at most one matching slot and move remaining keys down
             j = 0
             for i in range(_MAX_KEYPRESSES):
                 pressed = self.report_keys[i]
-                if (not pressed) or (pressed == keycode):
+                if not pressed:
+                    break  # Handled all used report slots
+                if pressed == keycode:
                     continue  # Remove this entry
-                self.report_keys[j] = self.report_keys[i]
+                if i != j:
+                    self.report_keys[j] = self.report_keys[i]
                 j += 1
-            # Check all the slots, just in case there's a duplicate. (There should not be.)
-            while j < _MAX_KEYPRESSES:
+            # Clear any remaining slots
+            while j < _MAX_KEYPRESSES and self.report_keys[j]:
                 self.report_keys[j] = 0
                 j += 1