R-203: the app and its backup look in the same directory — one resolver, every caller

appbackup's path helpers take a NAMESPACE ROOT. Five call sites passed a bare DRIVE path.
On an enrolled drive the two coincide, so nothing showed; on the system-data fallback they
differ by exactly the felhom-data segment, and the app then bound a directory the off-site
capture set never looked at -- while the run reported ok. Measured live on demo-hp: the app
wrote to /mnt/sys_drive/userdata/media/books, the capture set looked for
/mnt/sys_drive/felhom-data/userdata/media/books.

THE RULE NOW HAS ONE EXPRESSION. appbackup.NamespaceRootFor / IsEnrolledDrive encode the
drive-kind comparison; backup.Manager.namespaceRoot and stacks.Manager.inGuest delegate to
it. There were already TWO copies and they differed -- the backup package's compared without
filepath.Clean, the stacks package's with it, so a trailing slash from config would have
flipped the mode in one and not the other.

Sites routed through it:
  - stacks/deploy.go withPathVars -> ${USERDATA_PATH}   (the live defect)
  - appexport/fabplan.go + export.go                     (via a new provider method)
  - web/handlers.go FileBrowser mounts                   (latent: the system drive is
    deliberately never a registered StoragePath, so this is the identity today)

ComputeFabBuckets now receives the namespace root, which is what ComputeCaptureSet has always
received -- so the export's classified paths and the backup's capture set describe the same
directories by construction instead of by coincidence.

Tests are table-driven over BOTH drive kinds, because this survived by being invisible on the
kind that already worked. Red-proofs observed: restoring the bare-path call fails the
system-drive row with the two paths differing by /felhom-data; inverting the drive-kind
comparison fails every enrolled row.

controller/internal/stacks/migrate.go

@@ -277,8 +277,24 @@ func (m *Manager) startMigration(scope, sourcePath, appName, targetPath string,
 // inGuest reports whether drivePath is a user drive (its in-guest mount IS the felhom-data namespace
 // root) vs the system/SSD path (which holds a felhom-data SUBDIR). Compares cleaned paths so the
 // decision is stable regardless of slash style.
+// StackNamespaceRoot resolves an app's felhom-data NAMESPACE ROOT from its HDD_PATH (R-203). Exported
+// because the export adapter needs the same answer the backup side already computes, and only this
+// Manager holds the system-data path. Empty HDD_PATH → empty (the caller decides what that means).
+func (m *Manager) StackNamespaceRoot(name string) string {
+	cfg := m.LoadAppConfigByName(name)
+	if cfg == nil {
+		return ""
+	}
+	hdd := cfg.Env["HDD_PATH"]
+	if hdd == "" {
+		return ""
+	}
+	return appbackup.NamespaceRootFor(hdd, m.sysDataPath)
+}
+
 func (m *Manager) inGuest(drivePath string) bool {
-	return filepath.Clean(drivePath) != filepath.Clean(m.sysDataPath)
+	// R-203: the ONE expression of the rule now lives in appbackup; this is the stacks-side name for it.
+	return appbackup.IsEnrolledDrive(drivePath, m.sysDataPath)
 }
 
 // appSourceNS resolves an app's current source drive path + felhom-data namespace root from its