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 renamed to compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__unreachable_use_after_panic_1.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`.

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

@@ -0,0 +1,27 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\n        import module\n        pub fn a() {\n            panic\n            use <- module.wibble\n            1\n        }\n        "
+---
+----- SOURCE CODE
+-- module.gleam
+pub fn wibble(_) { 1 }
+
+-- main.gleam
+
+        import module
+        pub fn a() {
+            panic
+            use <- module.wibble
+            1
+        }
+        
+
+----- WARNING
+warning: Unreachable code
+  ┌─ /src/warning/wrn.gleam:5:13
+  │  
+5 │ ╭             use <- module.wibble
+6 │ │             1
+  │ ╰─────────────^
+
+This code is unreachable because it comes after a `panic`.

compiler-core/src/type_/tests/warnings.rs

@@ -1841,7 +1841,7 @@ fn doesnt_warn_twice_for_unreachable_code_if_has_already_warned_in_a_block_2() {
 }
 
 #[test]
-fn unreachable_use_after_panic() {
+fn unreachable_use_after_panic_1() {
     assert_warning!(
         r#"
         pub fn wibble(_) { 1 }
@@ -1854,6 +1854,21 @@ fn unreachable_use_after_panic() {
     );
 }
 
+#[test]
+fn unreachable_use_after_panic_2() {
+    assert_warning!(
+        ("package", "module", r#"pub fn wibble(_) { 1 }"#),
+        r#"
+        import module
+        pub fn a() {
+            panic
+            use <- module.wibble
+            1
+        }
+        "#
+    );
+}
+
 #[test]
 fn unreachable_code_after_case_subject_panics_1() {
     assert_warning!(