Inline safe_arith methods (#3229)

## Proposed Changes

Speed up epoch processing by around 10% by inlining methods from the `safe_arith` crate.

The Rust standard library uses `#[inline]` for the `checked_` functions that we're wrapping, so it makes sense for us to inline them too.

## Additional Info

I conducted a brief statistical test on the block at slot [3858336](https://beaconcha.in/block/3858336) applied to the state at slot 3858335, which requires an epoch transition. The command used for testing was:

```
lcli transition-blocks --testnet-dir ./common/eth2_network_config/built_in_network_configs/mainnet --no-signature-verification state.ssz block.ssz output.ssz
``` 

The testing found that inlining reduced the epoch transition time from 398ms to 359ms, a reduction of 9.77%, which was found to be statistically significant with a two-tailed t-test (p < 0.01). Data and intermediate calculations can be found here: https://docs.google.com/spreadsheets/d/1tlf3eFjz3dcXeb9XVOn21953uYpc9RdQapPtcHGH1PY

consensus/safe_arith/src/lib.rs

@@ -20,6 +20,7 @@ macro_rules! assign_method {
         #[doc = "Safe variant of `"]
         #[doc = $doc_op]
         #[doc = "`."]
+        #[inline]
         fn $name(&mut self, other: $rhs_ty) -> Result<()> {
             *self = self.$op(other)?;
             Ok(())
@@ -68,30 +69,37 @@ macro_rules! impl_safe_arith {
             const ZERO: Self = 0;
             const ONE: Self = 1;
 
+            #[inline]
             fn safe_add(&self, other: Self) -> Result<Self> {
                 self.checked_add(other).ok_or(ArithError::Overflow)
             }
 
+            #[inline]
             fn safe_sub(&self, other: Self) -> Result<Self> {
                 self.checked_sub(other).ok_or(ArithError::Overflow)
             }
 
+            #[inline]
             fn safe_mul(&self, other: Self) -> Result<Self> {
                 self.checked_mul(other).ok_or(ArithError::Overflow)
             }
 
+            #[inline]
             fn safe_div(&self, other: Self) -> Result<Self> {
                 self.checked_div(other).ok_or(ArithError::DivisionByZero)
             }
 
+            #[inline]
             fn safe_rem(&self, other: Self) -> Result<Self> {
                 self.checked_rem(other).ok_or(ArithError::DivisionByZero)
             }
 
+            #[inline]
             fn safe_shl(&self, other: u32) -> Result<Self> {
                 self.checked_shl(other).ok_or(ArithError::Overflow)
             }
 
+            #[inline]
             fn safe_shr(&self, other: u32) -> Result<Self> {
                 self.checked_shr(other).ok_or(ArithError::Overflow)
             }