Add better unreachable code warnings when a panic is before a use expression.

With previous changes, a test was broken when a panic was right before a
use expression. The test was like that:
```gleam
pub fn wibble(_) { 1 }
pub fn main() {
    panic
    use <- wibble
    1
}
```

This was the case because, before these changes, `UntypedExpr::Var`
has not special call path in `do_infer_call` function. `infer` and
`infer_or_error` was called has expected and a warning was emitted by
`warn_for_unreachable_code` in case of a previous panic expression.

Actually, `UntypedExpr::FieldAccess` has a special call path in
`do_infer_call` and compiler does not warned about a program like that:
```gleam
// Define pub fn wibble(_) { 1 }
import mylib/mymod
pub fn main() {
  panic
  use <- mymod.wibble
  1
}
```

With this change, use expression are always warned after a panic
expression.

Author: realraphrous

compiler-core/src/type_/expression.rs

@@ -852,6 +852,14 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         // We use `stacker` to prevent overflowing the stack when many `use`
         // expressions are chained. See https://github.com/gleam-lang/gleam/issues/4287
         let infer_call = || {
+            // We need this in the case where `call.function` has a special call path depending
+            // on the type such as `UntypedExpr::Var`. In these cases, `infer_call` does not call
+            // `infer_or_error`. `infer_or_error` is responsible for registering warnings about
+            // unreachable code and thus, warnings about unreachable code are not registered.
+            if self.previous_panics {
+                self.warn_for_unreachable_code(call_location, PanicPosition::PreviousExpression);
+            }
+
             self.infer_call(
                 *call.function,
                 call.arguments,

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__unreachable_use_after_panic.snap

@@ -14,9 +14,10 @@ expression: "\n        pub fn wibble(_) { 1 }\n        pub fn main() {\n
 
 ----- WARNING
 warning: Unreachable code
-  ┌─ /src/warning/wrn.gleam:5:20
-  │
-5 │             use <- wibble
-  │                    ^^^^^^
+  ┌─ /src/warning/wrn.gleam:5:13
+  │  
+5 │ ╭             use <- wibble
+6 │ │             1
+  │ ╰─────────────^
 
 This code is unreachable because it comes after a `panic`.