bytes_to_str and `.to_s(encoding)`: make encoding constant
Recently I did [a change in C++ runtime](https://github.com/kaitai-io/kaitai_struct_cpp_stl_runtime/pull/61) in regards to `bytes_to_str(...)` implementation. Basically, it boils down to setting this as `const char *` instead of `std::string` to facilitate compile-time resolution of encodings as much as possible:

```diff
-std::string kaitai::kstream::bytes_to_str(std::string src, std::string src_enc) {
+std::string kaitai::kstream::bytes_to_str(const std::string src, const char *src_enc) {
```

Unfortunately, while doing so, I've overlooked the fact that KS compiler currently treats `bytes_to_str` as operation which receives AST expression rather than a constant string for the encoding, and this broke a lot of tests for C++.

While `encoding: XXX` specification in both MetaSpec `encoding` and MemberSpec `encoding` YAML is very straightforward and does not really allow any flexibility or expression language usage, we actually introduced some time ago `.to_s(encoding)` operation in expression language itself, which, given that it is in the expression language, takes encoding as a parameter which can be constructed dynamically.

Despite how cool having generalization of this sounds like, I now start to think it was a poor design choice. In reality, there is a big swath of languages/platforms which want encoding to be represented in a very specific way. Three obvious examples:

* [Win32API C++ encoding conversions](https://github.com/kaitai-io/kaitai_struct_cpp_stl_runtime/blob/1f2837e6c5b73494d506ffad194e72ed17c9c99f/kaitai/kaitaistream.cpp#L706) don't speak encoding names, but rather convert encoding name into a codepage number.
* [golang encoding implementation in ksc](https://github.com/kaitai-io/kaitai_struct_compiler/blob/b5478e9f97c54221fcd346d88b71fb246395b179/shared/src/main/scala/io/kaitai/struct/translators/GoTranslator.scala#L290-L310) basically has a mapping of KS encoding names into Go constants + package names.
* [Nim runtime](https://github.com/kaitai-io/kaitai_struct_nim_runtime/commit/e0caf578a9c7beba00c9b1bedaed34953b68878e) has to have a special fix applied to solve the same encoding canonicalization problem in runtime.

## Proposal

What I'm proposing is basically getting rid of this "dynamic encoding" capability and just mandate that for everything related to encodings, we only take constants, and that's it. It's already this way for `encoding: xxx` designation in .ksy, and for `.to_s(encoding)` expression language, we'll have an expression language precompile check that ensures that string `.to_s` operation is only called with a constant string, never a dynamic object like `.to_s("IB" + "M4" + "37")`.

Any major use cases I'm overlooking or any objections?