Buildings and levels for the floor map, and make every identifier searchable

The map was one picture of one floor. A second floor was added, the blueprint
changed size, and machines moved, so a position now records WHICH DRAWING its
coordinates belong to.

Buildings and levels (ADR-017). Each level owns its blueprint per theme and its
own native pixel size; assets.mapx/mapy are pixels of assets.levelid, not of the
site. A position whose level is unknown renders "level unknown" and is never
drawn on the default level, because a marker on the wrong floor plan looks
entirely correct while pointing at the wrong place.

Repositioning in bulk: filter by unplaced, needs-review or level, search, place,
confirm. Landmark recalibration solves the transform PER AXIS from landmark
pairs and never from image dimensions - the canvas grew taller without
rescaling, so a dimension-derived scale would stretch Y by 1.57 and be wrong
everywhere. It defaults to a dry run, reports what would land off the drawing,
snapshots before applying, and clears mapverifiedat because a transform is a
guess awaiting review. Snapshots restore, including the level and the review
state, and a restore snapshots first so an undo is undoable.

Search: gaugelabreference was matched only for measuring tools and
maintenancereference was matched nowhere at all, for any asset type, while
Settings happily offers both identifiers on machines and PCs. A tag an operator
is told to record has to be findable or it is a write-only field. USB devices
and printed items were unreachable from search entirely - neither is an asset,
so the generic asset search could not see them and no searcher existed; they
now match on serial, asset tag, label, bin code and gage-lab tag, honouring
isactive, with Settings toggles and result labels to match.

The retired-application rule was half a rule: GET /api/knowledgebase hid
articles whose topic application is retired while global search still returned
them and printed the retired application as the subject. A filter is only real
if every path that reaches the row applies it.

Contract to 0.20.0 (additive): Asset gained levelid and mapverifiedat, Location
gained levelid, and resolve_asset_position returns the levelid belonging to
whichever source supplied the coordinates. The five plugins that write a map
position are re-pinned. The install-list text format gained levelid as a NINTH
field, appended, because the shipped Pascal installer reads fields 0-7 by index.

That installer still compiles in one drawing's dimensions and bundles one
blueprint, so its map is accurate for the default level only; /api/maplevels is
deliberately unauthenticated so it can read both at runtime once rebuilt.
Recorded in PRINTER-INSTALLER.md section 6 along with the other known gaps.

Migration 7d33 converts an existing single-map site into one building and one
default level carrying the old map_* settings, then assigns every placed asset
and location to it. Nothing moves on screen. Old settings rows are kept so a
rollback still finds them. Verified end to end on MySQL 5.6 from a
production-shaped database.

shopdb/api/__init__.py

@@ -196,7 +196,10 @@ def _walk_related_for_position(asset, visited, depth):
         n_mapx = getattr(neighbor, 'mapx', None)
         n_mapy = getattr(neighbor, 'mapy', None)
         if n_mapx is not None and n_mapy is not None:
-            return (n_mapx, n_mapy)
+            # The neighbour's LEVEL travels with its coordinates. Returning the
+            # pair alone would leave the caller drawing a machine's position on
+            # whatever level the PC that borrowed it happens to claim.
+            return (n_mapx, n_mapy, getattr(neighbor, 'levelid', None))
 
         recursed = _walk_related_for_position(neighbor, visited, depth + 1)
         if recursed is not None:
@@ -214,18 +217,28 @@ def resolve_asset_position(asset) -> Optional[Dict[str, Any]]:
       3. Asset's location coords (asset.location.mapx, .mapy)
       4. None (asset is unplaced, rendered in a tray)
 
-    Returns a dict {'mapx', 'mapy', 'positionsource'} where positionsource
-    is one of 'self', 'related', 'location'. Returns None when no priority
-    yields coordinates.
+    Returns a dict {'mapx', 'mapy', 'levelid', 'positionsource'} where
+    positionsource is one of 'self', 'related', 'location'. Returns None when no
+    priority yields coordinates.
+
+    LEVELID COMES FROM WHICHEVER SOURCE SUPPLIED THE COORDINATES, not from the
+    asset (ADR-017). A PC with no position of its own that inherits from the
+    machine it controls is at the MACHINE's coordinates on the MACHINE's level;
+    using the PC's own level - which may be null, or may be a different building
+    entirely - would draw those coordinates on the wrong drawing, and the result
+    looks entirely reasonable.
     """
     mapx = getattr(asset, 'mapx', None)
     mapy = getattr(asset, 'mapy', None)
     if mapx is not None and mapy is not None:
-        return {'mapx': mapx, 'mapy': mapy, 'positionsource': 'self'}
+        return {'mapx': mapx, 'mapy': mapy,
+                'levelid': getattr(asset, 'levelid', None),
+                'positionsource': 'self'}
 
     related = _walk_related_for_position(asset, set(), 0)
     if related is not None:
-        return {'mapx': related[0], 'mapy': related[1], 'positionsource': 'related'}
+        return {'mapx': related[0], 'mapy': related[1], 'levelid': related[2],
+                'positionsource': 'related'}
 
     location = getattr(asset, 'location', None)
     if location is not None:
@@ -235,6 +248,7 @@ def resolve_asset_position(asset) -> Optional[Dict[str, Any]]:
             return {
                 'mapx': loc_mapx,
                 'mapy': loc_mapy,
+                'levelid': getattr(location, 'levelid', None),
                 'positionsource': 'location',
             }