Time Args support for month string values

[b-n]

Another follow on from #2410 and #2411.
Related to #2223

Time#utc, Time#local, and friends all support specifying a month value from the shortened 3 character english names for the month.

Ref: https://ruby-doc.org/3.1.2/Time.html#method-c-utc

[lopopolo]

love that we're getting so close to parity here. I find the structure of the if let hard to follow. It reminds me of this pattern in golang which I also find hard to read:

if err := func() {
    // do
    // the
    // thing
    return err
    // do
    // do
    // do
    return nil
}(); err != nil {
    return nil
}

I think the simplest way to do the case insensitivity is with an allocation to Vec<u8> combined with BStr::make_ascii_lowercase. Maybe we can short circuit if the length of the byteslice != 3?

[lopopolo]

since we're checking against an ASCII allowlist, we can use &[u8] and b"jan" byte literals here to avoid a UTF-8 decode.

[b-n]

make_ascii_lowercase() - which nicely does convert in place - needed a &mut [u8] conversion for Artichoke (which doesn't exist currently). I assume that's for a reason rather than adding my own - so the only way this was possible was to make it convert to a Vec, and do the comparison of byte slices with as_slice().

Is there any particular reason there isn't a conversion to &mut [u8] as of yet?

[b-n]

Note:

impl<'a> TryConvertMut<Value, &'a mut [u8]> for Artichoke {
    type Error = Error;

    fn try_convert_mut(&mut self, mut value: Value) -> Result<&'a mut [u8], Self::Error> {
        self.protect(value);
        let mut s = unsafe { String::unbox_from_value(&mut value, self)? };
        // SAFETY: This transmute modifies the lifetime of the byte slice pulled
        // out of the boxed `String`. This requires that no garbage collections
        // that reclaim `value` occur while this slice is alive. This is
        // enforced for at least this entry from an mruby trampoline by the call
        // to `protect` above.
        //
        // FIXME: does this unbound lifetime and transmute below allow
        // extracting `&'static [u8]`?
        let slice = unsafe { mem::transmute(s.as_inner_mut().as_mut_slice()) };
        Ok(slice)
    }
}

appears to be "valid rust". I am very okay in admitting that I'm not entirely sure if this makes 100% rust/memory sense (still a topic I need to get a properly deep understanding of)

[lopopolo]

I left some style suggestions which you don't need to take. Logic LGTM.