Tuples have a fixed type (you can't change a tuple element to have a different type) and fixed length (you can't add a new type to the end of an existing tuple) but elements in the tuple can be mutated if the variable is declared as mutable.
In most cases, what you'll see under the hood (with Godbolt or similar) is approximately this:
A region allocated in the .static part of your program to hold the sequence "ken", "rust", "tup.0 = ", "What in the world is this??", and "tup.4 = "`. This area is mapped into memory when your program is loaded at a known location.
The tuple tup represented on the stack, in a continuous region that's at least (size of pointer) + (size of f64) + (size of bool) + (size of char) + (size of pointer) long. Note that all of those sizes are compile-time constants.
The program writes pointers pointing into the .static region into the stack regions representing tup.0 and tup.4, at the appropriate time in your program's execution.
This is actually a gross simplification, and (especially in release builds) the actual generated code may be very different from this, but this is a reasonable rote translation and I hope helps understand what's going on. The tuple itself is like allocated on the stack, and the strings you're using are allocated statically.
I sense that &str is actually a pointer to a heap address thus making tuple elements of string type mutable. The docs say the length is fixed, so, I guess the pointer approach is valid. The pointers never change in length.
Thus I can change the contents of a &str slice which is on the heap. Yes?
They are pointers (that's what the & in the type means), but not necessarily to the heap. In this case, the strings don't live in the heap, but rather in a static area of memory that contains all the string literals that exist in your program.
The "length" in this context means "the number of elements of the tuple". In your case, the tuple length is 5 and isn't changing.
The strings? No. In a rote translation, they'd be copied into the program's static segment and loaded into memory at startup. They'd stay there throughout the life of the program, only leaving memory when the program is unloaded by the OS after it exits.
The static segment is closer to "heap" than "stack," but it's not really either of those things. It's a separate region defined by the loader and usually made read-only. The tuple is mutable, so you can change what strings the tuple refers to, but the strings themselves - at least the ones you're using - are read-only.
If you want a mutable string, there are a few ways to get one - a String, which allocates a buffer on the heap for you, or a [char; N] array, which may live on the stack, or Vec<u8>, can all provide storage that can be converted to &str or &mut str in the right contexts.
My thanks to all of you. I am learning Rust. It is an amazing tool. Using VS Code. This community is very prompt and clearly helpful. I am understanding more & more why Rust is so free of aggravating bugs.