Support mounting file systems & migrate devices to use mounts (microsoft#995)

This PR introduces the `Composer`, which acts as a mount point for the
new core file system design (see microsoft#887). It maintains a runtime list of
dyn-safe `Backend` objects for each mount point, using as much walking
as feasible under the mount points.

To exercise the `Composer` and demonstrate how it works, I've also
switched `Devices` to stop being hardcoded to `/dev` _inside_ the
backend but instead be a flat list of devices that is _mounted_ at
`/dev`.

While this PR does not expose/use it this way yet, with this PR, finally
LiteBox core now has some of the fundamental machinery needed to
eventually support `mount(2)` family of syscalls in the Linux shim.

Future PRs will continue migrating more backends over, eventually
allowing for the old layered file system to disappear, and replaced with
this mount composition + (upcoming) overlay file system to support union
mounting.

Author: jaybosamiya-ms

litebox/src/fs/backend.rs

@@ -211,7 +211,10 @@ impl<'a> WalkingDirHandle<'a> {
         }
     }
 
-    /// Recover the concrete walking handle stored in this erased handle for `B`.
+    /// Recover the concrete handle stored in this erased handle.
+    ///
+    /// Intended to be called by backend implementations as `handle.into_typed::<Self>()` on
+    /// handles that the resolver passed back to the same backend; it may panic otherwise.
     pub(super) fn into_typed<B: BackendHandles + 'static>(self) -> B::WalkingDirHandle<'a> {
         assert_eq!(
             self.backend_type,
@@ -234,6 +237,10 @@ impl FileHandle {
         }
     }
 
+    /// Borrow the concrete handle stored in this erased handle.
+    ///
+    /// Intended to be called by backend implementations as `handle.get_typed::<Self>()` on handles
+    /// that the resolver passed back to the same backend; it may panic otherwise.
     pub(super) fn get_typed<B: BackendHandles>(&self) -> &B::FileHandle {
         (&*self.raw as &dyn Any)
             .downcast_ref::<B::FileHandle>()
@@ -248,12 +255,20 @@ impl DirHandle {
         }
     }
 
+    /// Borrow the concrete handle stored in this erased handle.
+    ///
+    /// Intended to be called by backend implementations as `handle.get_typed::<Self>()` on handles
+    /// that the resolver passed back to the same backend; it may panic otherwise.
     pub(super) fn get_typed<B: BackendHandles>(&self) -> &B::DirHandle {
         (&*self.raw as &dyn Any)
             .downcast_ref::<B::DirHandle>()
             .expect("backend directory handle type mismatch")
     }
 
+    /// Recover the concrete handle stored in this erased handle.
+    ///
+    /// Intended to be called by backend implementations as `handle.into_typed::<Self>()` on
+    /// handles that the resolver passed back to the same backend; it may panic otherwise.
     pub(super) fn into_typed<B: BackendHandles>(self) -> B::DirHandle {
         let raw: Box<dyn Any> = self.raw;
         *raw.downcast::<B::DirHandle>()