Fix: Object::from_ref no longer forgetting to increment the strong count

[MikaelMayer]

Fixes #5851
This PR adds the following safety checks

• If the strong count is not updated, we will panic instead of silently returning a Rc pointer that would cause dangling pointers if dropped. Adding these checks helped me reproduce the soundness issue all the time locally, but obviously did not fix it. I'm keeping it there just in case.
• Itmakes the strong count increment opaque to the compiler, so that it should prevent optimizations that would skip the strong count from increasing. It also makes it opaque at the call site. This did not prevent the compiler from optimizing it away unfortunately in at least one experiment, but I'll keep it just in case it's was another lurking issue.
• Added #[inline(never)] to the function from_ref did fix the soundness issue.
• I tried the following but it did not do anything, so not implementing: Instead of incrementing the strong count from the pointer obtained by &T, it increments the strong count from the pointer obtained by the extracted Rc<T> by doing it the normal way

An alternative to avoid all this hassle would be to pass self: &Rc<Self> instead of self: &Self, which is what the branch https://github.com/dafny-lang/dafny/tree/fix-object-safety-rust does, but &Rc does not make traits object-safe, which means we can't yet use them in the code. I tried also passing a second arguments so that we directly have a Rc<> and don't need to recover it from the &T, but this: Rc<Self> again makes the trait not object-safe, and this: Rc<dyn Any> causes an issue because we can't create this argument when what we have is only the trait, and trait upcast to Any is currently unsound in Rust. This PR is the best workaround I found so far.

By submitting this pull request, I confirm that my contribution is made under the terms of the MIT license.