Generate &'static CStr from Encoding

[madsmtm]

Idea is that we generate an array in a const fn, and then get a reference to that array and put it in a const.

Requires rust-lang/rust#76560.

Another approach would be to require Encode implementors to add a macro to the end, like this:

unsafe impl Encode for MyType {
    const ENCODING: Encoding<'static> = ...;
    end_encode_impl!();
}

[madsmtm]

Though of course rust-lang/const-eval#20 would make this much, much easier!

[madsmtm]

I tried with a design like:

trait Encode {
    // ...

    #[doc(hidden)]
    const __ENCODING_CSTR_LEN: usize = Self::ENCODING.static_encoding_str_len();

    #[doc(hidden)]
    const __ENCODING_CSTR_ARRAY: [u8; 128] = {
        if Self::__ENCODING_CSTR_LEN >= 127 {
            panic!("encoding string was too long! The maximum supported length is 127.");
        }

        Self::ENCODING.static_encoding_str_array()
    };

    /// The encoding as a static [`CStr`].
    ///
    /// This has the same output as `Encoding::to_string`, but it is created
    /// at compile-time instead.
    ///
    /// The encoding is guaranteed to be a pure ASCII string.
    #[cfg(feature = "std")]
    const ENCODING_CSTR: &'static CStr = {
        let mut slice: &[u8] = &Self::__ENCODING_CSTR_ARRAY;
        // Cut down to desired size (length + 1 for NUL byte)
        // Equivalent to:
        // slice[0..Self::__ENCODING_CSTR_LEN + 1]
        while slice.len() > Self::__ENCODING_CSTR_LEN + 1 {
            if let Some(res) = slice.split_last() {
                slice = res.1;
            } else {
                unreachable!();
            }
        }
        unsafe { CStr::from_bytes_with_nul_unchecked(slice) }
    };
}

The idea being that hopefully, the compiler would be able to see that the rest of __ENCODING_CSTR_ARRAY wasn't used, and only emit the bytes referenced by ENCODING_CSTR.

That doesn't seem to work though, the entire __ENCODING_CSTR_ARRAY seems to be present in the final binary, so this approach won't work (because it'll be bad for code size if we choose a max string length that is too big, and if we choose a max length that is too small, it'll cause errors).

[madsmtm]

I've gone with a different approach in this PR now: generate the static method encodings only inside define_class! - since it isn't in a generic context, so we can do it there.

A fully generic solution still requires #![feature(generic_const_exprs)] (or equivalent).