Monotonic rewrite (#874)

* Rework timer_queue and monotonic architecture

Goals:
 * make Monotonic purely internal
 * make Monotonic purely tick passed, no fugit involved
 * create a wrapper struct in the user's code via a macro that then
   converts the "now" from the tick based monotonic to a fugit based
   timestamp

We need to proxy the delay functions of the timer queue anyway,
so we could simply perform the conversion in those proxy functions.

* Update cargo.lock

* Update readme of rtic-time

* CI: ESP32: Redact esp_image: Too volatile

* Fixup: Changelog double entry rebase mistake

---------

Co-authored-by: Henrik Tjäder <henrik@tjaders.com>

examples/stm32g030f6_periodic_prints/src/main.rs

@@ -0,0 +1,57 @@
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![no_main]
+#![no_std]
+
+use defmt_rtt as _; // global logger
+
+pub use stm32g0xx_hal as hal; // memory layout
+
+use panic_probe as _;
+
+// same panicking *behavior* as `panic-probe` but doesn't print a panic message
+// this prevents the panic message being printed *twice* when `defmt::panic` is invoked
+#[defmt::panic_handler]
+fn panic() -> ! {
+    cortex_m::asm::udf()
+}
+
+use rtic_monotonics::stm32::prelude::*;
+stm32_tim3_monotonic!(Mono, 1_000_000);
+
+#[rtic::app(device = hal::stm32, peripherals = true, dispatchers = [USART1, USART2])]
+mod app {
+    use super::*;
+
+    #[local]
+    struct LocalResources {}
+
+    #[shared]
+    struct SharedResources {}
+
+    #[init]
+    fn init(ctx: init::Context) -> (SharedResources, LocalResources) {
+        // enable dma clock during sleep, otherwise defmt doesn't work
+        ctx.device.RCC.ahbenr.modify(|_, w| w.dmaen().set_bit());
+
+        defmt::println!("TIM Monotonic blinker example!");
+
+        // Start the monotonic
+        Mono::start(16_000_000);
+
+        print_messages::spawn().unwrap();
+
+        (SharedResources {}, LocalResources {})
+    }
+
+    #[task(priority = 2)]
+    async fn print_messages(_cx: print_messages::Context) {
+        let mut next_update = <Mono as Monotonic>::Instant::from_ticks(0u64);
+
+        loop {
+            defmt::println!("Time: {} ticks", Mono::now().ticks());
+            next_update += 1000u64.millis();
+            Mono::delay_until(next_update).await;
+        }
+    }
+}