feat: concurrent kernel captures, one per interface

uBridge's capture module now serves one AF_PACKET capture per interface,
any number per process, and `capture stop_kernel` takes the interface it
stops — this rides that (breaking, paired-binary) protocol change.

The server-side single-slot tracker (_kernel_capture_ifc with its
reserve/release/owned_by helpers) is gone: same-port duplicates were
already refused by the NIO capturing flag, uBridge answers EALREADY on a
same-interface duplicate, and per-interface stops removed the process-
wide stop the ownership gating guarded against.

The docker e2e drives ten concurrent captures on one node's uBridge and
asserts a per-interface stop freezes exactly the stopped half while the
live half keeps recording.

gns3server/compute/vpcs/vpcs_vm.py

@@ -659,14 +659,11 @@ class VPCSVM(KernelDatapathMixin, BaseNode):
             anchor = self._kernel_host_ifc(0, port_number)
             if isinstance(nio, NIOBridge) and anchor is not None:
                 # Kernel link: capture on the adapter's TAP anchor (AF_PACKET,
-                # one capture per uBridge process — see _reserve_kernel_capture;
-                # a failed start rolls the port's flag back so the port cannot
-                # later stop the winner's capture).
+                # one capture per interface — a failed start rolls the port's
+                # flag back).
                 try:
-                    self._reserve_kernel_capture(anchor)
                     await self._ubridge_send(f'capture start_kernel {anchor} "{output_file}"')
                 except Exception:
-                    self._release_kernel_capture(anchor)
                     nio.stop_packet_capture()
                     raise
             else:
@@ -693,12 +690,8 @@ class VPCSVM(KernelDatapathMixin, BaseNode):
         if self.ubridge:
             anchor = self._kernel_host_ifc(0, port_number)
             if isinstance(nio, NIOBridge) and anchor is not None:
-                # Process-wide and argument-less: only the port owning the
-                # slot may stop it (a second port's stop would kill this
-                # capture while its own flag still says capturing).
-                if self._kernel_capture_owned_by(anchor):
-                    await self._ubridge_send("capture stop_kernel")
-                    self._release_kernel_capture(anchor)
+                # Per-interface stop: only this port's capture is stopped.
+                await self._ubridge_send(f'capture stop_kernel {anchor}')
             else:
                 await self._ubridge_send("bridge stop_capture {name}".format(name=f"VPCS-{self._id}"))