Restore manganis optimizations (#3195)

* Create a crate for constant serialization of config structs for manganis
* use SerializeConst for the image asset builder
* switch to a declarative macro for assets
* add serializable options for each asset type
* implement the new manganis macro
* optimize assets in the CLI
* Fix assets with dioxus formattable
* reduce fuzzing test limits
* use the new syntax in examples
* fix avif support
* Fix manganis doc tests
* cache asset optimization
* Split out asset and bundled asset
* make hash pointer width independent
* Fix manganis macro docs
* add constvec::is_empty method to fix clippy lint
* remove nasm feature
* simplify test_rsplit_once test so typos passes
* revert example change from clippy fix
* always accept unix paths
* fix windows path seperator
* fix folder asset hash
* Optimize assets in a blocking task
* Fix asset options docs
* Document Asset and BundledAsset
* simplify the linker macro a bit
* add more docs to AssetParser expansion
* add image format helpers
* Split by  both unix and windows path separators and take the smallest one

packages/const-serialize/src/const_buffers.rs

@@ -0,0 +1,33 @@
+/// A buffer that can be read from at compile time. This is very similar to [Cursor](std::io::Cursor) but is
+/// designed to be used in const contexts.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct ConstReadBuffer<'a> {
+    location: usize,
+    memory: &'a [u8],
+}
+
+impl<'a> ConstReadBuffer<'a> {
+    /// Create a new buffer from a byte slice
+    pub const fn new(memory: &'a [u8]) -> Self {
+        Self {
+            location: 0,
+            memory,
+        }
+    }
+
+    /// Get the next byte from the buffer. Returns `None` if the buffer is empty.
+    /// This will return the new version of the buffer with the first byte removed.
+    pub const fn get(mut self) -> Option<(Self, u8)> {
+        if self.location >= self.memory.len() {
+            return None;
+        }
+        let value = self.memory[self.location];
+        self.location += 1;
+        Some((self, value))
+    }
+
+    /// Get a reference to the underlying byte slice
+    pub const fn as_ref(&self) -> &[u8] {
+        self.memory
+    }
+}