Fix overly strict sendability checks

Some changes introduced in 0.18.0 resulted in checks for sendable
values/calls being overly strict. For example, it was no longer allow to
return a `uni ref T` value through methods such as Array.get even when
this poses no problems. In addition, the checks for sendable output
types didn't handle generic types properly resulting in them not being
considered sendable.

This commit fixes both these issues and adds some tests such that we can
hopefully catch future regressions.

Changelog: changed

Author: yorickpeterse

std/fixtures/diagnostics/return_uni_borrow.inko

@@ -0,0 +1,27 @@
+type A {}
+
+type B {
+  let @a: A
+  let @b: ref A
+
+  fn take(values: Array[uni B]) {}
+}
+
+fn borrow(value: ref B) {}
+
+fn example1(value: uni B) {
+  [value].get(0)
+}
+
+fn example2(value: uni B) {
+  borrow([value].get(0))
+}
+
+fn example3(value: uni B) {
+  let values = [value]
+
+  values.get(0).take(values)
+}
+
+# return_uni_borrow.inko:17:10 error(invalid-type): expected a value of type 'ref B', found 'uni ref B'
+# return_uni_borrow.inko:23:22 error(invalid-type): the receiver of this call requires sendable arguments, but 'Array[uni B]' isn't sendable

std/fixtures/diagnostics/sendable_generic_type.inko

@@ -0,0 +1,23 @@
+type MyMap[K, V] {
+  let @keys: Array[K]
+  let @values: Array[V]
+
+  fn clone -> Self {
+    MyMap(keys: [], values: [])
+  }
+}
+
+fn example1 {
+  let a = recover MyMap(keys: ['foo'], values: ['bar'])
+
+  a.clone
+}
+
+fn example2 {
+  let a = recover MyMap(keys: ['foo'], values: ['bar'])
+  let b = recover a.clone
+
+  b.invalid
+}
+
+# sendable_generic_type.inko:20:3 error(invalid-symbol): the method 'invalid' isn't defined for type 'uni MyMap[String, String]'