Bug fix for @bean returning Optional not registering extended type

Example:
```
@bean
Optional<CFace> optional() { ... }
```

The generated isBeanAbsent() method should include all the types that CFace extends such as interfaces. If CFace extends C2Face then both should be there like:

.isBeanAbsent(CFace.class, C2Face.class))

The bug was that only the top type of CFace was included like:

```
.isBeanAbsent(CFace.class))
```

This was due to a bug in MethodReader determining the incorrect returnElement for the optionalType = true case. The returnElement was the Optional type rather than the parameter type CFace.

Author: rbygrave

blackbox-test-inject/src/main/java/org/example/myapp/config/C2Face.java

@@ -0,0 +1,6 @@
+package org.example.myapp.config;
+
+public interface C2Face {
+
+  String msg();
+}

blackbox-test-inject/src/main/java/org/example/myapp/config/CFace.java

@@ -0,0 +1,4 @@
+package org.example.myapp.config;
+
+public interface CFace extends C2Face {
+}

blackbox-test-inject/src/main/java/org/example/myapp/config/CFactory.java

@@ -0,0 +1,35 @@
+package org.example.myapp.config;
+
+import io.avaje.inject.Bean;
+import io.avaje.inject.Factory;
+import jakarta.inject.Named;
+
+import java.util.Optional;
+
+@Factory
+class CFactory {
+
+  @Bean @Named("base")
+  CFace base() {
+    return new TheCFace("base");
+  }
+
+  @Bean @Named("optional")
+  Optional<CFace> optional() {
+    return Optional.of(new TheCFace("optional"));
+  }
+
+  static final class TheCFace implements CFace {
+
+    private final String msg;
+
+    TheCFace(String msg) {
+      this.msg = msg;
+    }
+
+    @Override
+    public String msg() {
+      return msg;
+    }
+  }
+}

blackbox-test-inject/src/test/java/org/example/myapp/config/CFactoryTest.java

@@ -0,0 +1,27 @@
+package org.example.myapp.config;
+
+import io.avaje.inject.BeanScope;
+import io.avaje.inject.test.TestBeanScope;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CFactoryTest {
+
+  @Test
+  void optionalWithCascadingInterfaces() {
+    try (BeanScope scope = TestBeanScope.builder().build()) {
+      C2Face base = scope.get(C2Face.class, "base");
+      CFace cface = scope.get(CFace.class, "optional");
+      C2Face c2face = scope.get(C2Face.class, "optional");
+      assertThat(base.msg()).isEqualTo("base");
+      assertThat(cface.msg()).isEqualTo("optional");
+      assertThat(c2face.msg()).isEqualTo("optional");
+
+      List<C2Face> list = scope.list(C2Face.class);
+      assertThat(list).hasSize(2);
+    }
+  }
+}

inject-generator/src/main/java/io/avaje/inject/generator/MethodReader.java

@@ -91,7 +91,10 @@ final class MethodReader {
     // for multiRegister we desire a qualifier name such that builder.isBeanAbsent() uses it and allows
     // other beans of the same type to also register, otherwise it defaults to slightly confusing behaviour
     this.name = multiRegister && qualifierName == null ? "multi" : qualifierName;
-    TypeElement returnElement = multiRegister ? APContext.typeElement(uType.mainType()) : asElement(returnMirror);
+    TypeElement returnElement =
+      multiRegister
+        ? APContext.typeElement(returnTypeRaw)
+        : optionalType ? APContext.typeElement(returnTypeRaw) : asElement(returnMirror);
     if (returnElement == null) {
       this.typeReader = null;
       this.initMethod = initMethod;

inject-generator/src/test/java/io/avaje/inject/generator/models/valid/ConfigFactory.java

@@ -1,6 +1,7 @@
 package io.avaje.inject.generator.models.valid;
 
 import java.util.Map;
+import java.util.Optional;
 
 import io.avaje.inject.Bean;
 import io.avaje.inject.Factory;
@@ -19,4 +20,10 @@ Map<String, Long> map1() {
   Map<String, String> map2(@Named("map1") Map<String, Long> map1) {
     return Map.of();
   }
+
+  @Bean
+  @Named("optionalA0")
+  Optional<A0> build() {
+    return Optional.empty();
+  }
 }