feat(dynamips): anchor every Ethernet port on a persistent TAP

Dynamips links can now ride the kernel datapath like Docker, QEMU and IOU:
each Ethernet slot/port gets a persistent TAP anchor (gd{id}e{slot}p{port}),
created through uBridge's tap module, and the Dynamips hypervisor opens it
with nio create_tap — the hypervisor holds the fd, exactly QEMU's shape.
Links attach the anchor to their per-link kernel bridge; the legacy UDP
tunnel remains the relay datapath for every other port.

Anchor lifecycle: born at node start (tap module probed with one
create/delete cycle, sweep of stale devices, ownership handed to the server
user, born down); a kernel link opens the anchor in the hypervisor, binds
the slot/port and enslaves it; removing the link releases the fd again
(nio delete) and detaches. A link bound while the router is stopped is
wired by the next start (deferred wiring). Node close follows QEMU's stop
order — the hypervisor's TAP NIOs go before tap delete, since it is
Dynamips, not uBridge, that holds the fds.

Stop is not close: vm stop only halts the emulated router, so the
hypervisor, the TAP fds, the bindings and the per-link bridges all survive
a stop/start untouched (attach skips ports that still hold their TAP NIO).

Port selection follows the adapter registry: ETHERNET_ADAPTERS and
ETHERNET_WICS name the models whose ports carry Ethernet frames (WIC-1ENET
included, at its Dynamips port number); serial, ATM and POS ports never
anchor, and a kernel link there errors with the relay-datapath message
instead of half-wiring. Adapters hot-added to a running router (OIR) get
their anchors at once.

The compute NIO routes accept nio_bridge alongside nio_udp (the same
widening QEMU needed), carry the endpoint's suspend flag on update (it is
the anchor's admin state on a kernel link), skip the hypervisor delete for
a kernel NIO (its TAP NIO was already released by the slot removal), and
the close path leaves NIOBridge instances to _stop_ubridge.

gns3server/api/routes/compute/dynamips_nodes.py

@@ -29,6 +29,7 @@ from fastapi.responses import StreamingResponse
 from gns3server import schemas
 from gns3server.compute.dynamips import Dynamips
 from gns3server.compute.dynamips.nodes.router import Router
+from gns3server.compute.nios.nio_bridge import NIOBridge
 
 from .dependencies.authentication import compute_authentication, ws_compute_authentication
 
@@ -173,12 +174,15 @@ async def reload_router(node: Router = Depends(dep_node)) -> None:
 @router.post(
     "/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
     status_code=status.HTTP_201_CREATED,
-    response_model=schemas.UDPNIO,
+    response_model=Union[schemas.UDPNIO, schemas.BridgeNIO],
     dependencies=[Depends(compute_authentication)],
 )
 async def create_nio(
-    adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: Router = Depends(dep_node)
-) -> schemas.UDPNIO:
+    adapter_number: int,
+    port_number: int,
+    nio_data: Union[schemas.UDPNIO, schemas.BridgeNIO],
+    node: Router = Depends(dep_node),
+) -> Union[schemas.UDPNIO, schemas.BridgeNIO]:
     """
     Add a NIO (Network Input/Output) to the node.
     """
@@ -191,12 +195,15 @@ async def create_nio(
 @router.put(
     "/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
     status_code=status.HTTP_201_CREATED,
-    response_model=schemas.UDPNIO,
+    response_model=Union[schemas.UDPNIO, schemas.BridgeNIO],
     dependencies=[Depends(compute_authentication)],
 )
 async def update_nio(
-    adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: Router = Depends(dep_node)
-) -> schemas.UDPNIO:
+    adapter_number: int,
+    port_number: int,
+    nio_data: Union[schemas.UDPNIO, schemas.BridgeNIO],
+    node: Router = Depends(dep_node),
+) -> Union[schemas.UDPNIO, schemas.BridgeNIO]:
     """
     Update a NIO (Network Input/Output) on the node.
     """
@@ -206,6 +213,10 @@ async def update_nio(
     if nio_data.filters:
         nio.filters = nio_data.filters
     nio.markers = nio_data.markers or {}
+    # Suspend is what the compute turns into an admin-down anchor on a
+    # kernel link (native carrier), so it must reach the NIO like it does
+    # on the Docker/QEMU/IOU routes.
+    nio.suspend = getattr(nio_data, "suspend", None) or False
     await node.slot_update_nio_binding(adapter_number, port_number, nio)
     return nio.asdict()
 
@@ -221,7 +232,10 @@ async def delete_nio(adapter_number: int, port_number: int, node: Router = Depen
     """
 
     nio = await node.slot_remove_nio_binding(adapter_number, port_number)
-    await nio.delete()
+    if not isinstance(nio, NIOBridge):
+        # A kernel NIO has no hypervisor side left: its TAP NIO was deleted
+        # by the slot binding removal itself.
+        await nio.delete()
 
 
 @router.post(