I have a question.
In a simple function there are two branches with almost identical instructions. When building with `opt-level = 3` and using a `match` statement, the instructions get optimized away somehow, or change in order and the application stops working. If I use `if matches!(..` it works.
This is the actual code:
```rust
    pub fn tx1(&mut self, delay: &mut impl DelayNs) -> OneWireResult<()> {
        match self.communication_speed {
            Speed::HighSpeed => {
                self.set_low()?;
                delay.delay_us(1); // tLOW1 (High Speed)
                self.release_bus()?;
                delay.delay_us(14); // tBIT (High Speed)
            }
            Speed::Standard => {
                self.set_low()?;
                delay.delay_us(4); // tLOW1 (Standard Speed)
                self.release_bus()?;
                delay.delay_us(41); // tBIT (Standard Speed)
            }
        }

        Ok(())
    }

    fn release_bus(&mut self) -> OneWireResult<()> {
        self.pin
            .set_high()
            .map_err(|_| OneWireError::CouldNotSetPin)
    }

    #[inline(never)]
    fn set_low(&mut self) -> OneWireResult<()> {
        self.pin.set_low().map_err(|_| OneWireError::CouldNotSetPin)
    }
```

The solution here was to add `#[inline(never)]` to `set_low`. Is there a reason why `match` would change the order of those calls? or not call one function at all? How do I prevent the compiler from swapping things around?