Ok I was able to implement this in WELD. For completeness I report the code here so that you can comment it and tell me where I can improve the WELD and CGLIB part.
I see there is another implementation in this forum of a generic dao in WELD, but following a different approach with producer and interceptor. Maybe this extension is a little cleaner because doesn't force the user to configure an interceptor and doesn't need to write an empty producer.

Dao.java (the annotation)

@Documented
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Dao {
     
     Class<?> value();
 
}

GenericDao interface

public interface GenericDao<T, PK extends Serializable> {
     
     T load(PK id);

}

Generic dao implementation

public class GenericDaoImpl<T, PK extends Serializable> implements GenericDao<T, PK> {
     
    private Class<T> type;

     public T load(PK id) {
          System.out.println("load object of type " + getType().getName() + " from id " + id);
          try {
               return getType().newInstance();
          } catch (Exception e) {
               throw new RuntimeException(e);
          }
     }

     public void setType(Class<T> type) {
          this.type = type;
     }

     public Class<T> getType() {
          return type;
     };

}

CDI Extension.java:

public class MyExtension implements Extension {
     
     private final Collection<Bean<?>> additionalBeans = new ArrayList<Bean<?>>();

     public <X> void processAnnotatedType(
               @Observes final ProcessAnnotatedType<X> pat, final BeanManager bm) {

          final AnnotatedType<X> at = pat.getAnnotatedType();

          if (!at.isAnnotationPresent(Dao.class)) {
               return;
          }
          
          
          final Class<X> javaClass = at.getJavaClass();
          
          final Enhancer e = new Enhancer();
          e.setSuperclass(GenericDaoImpl.class);
          e.setInterfaces(new Class[]{javaClass});
          e.setCallback(new MethodInterceptor() {
               
               @Override
               public Object intercept(Object target, Method method, Object[] args,
                         MethodProxy proxy) throws Throwable {
                    if (method.getName().equals("setType")) {
                         return proxy.invokeSuper(target, args);
                    }
                    GenericDaoImpl genericDaoImpl = (GenericDaoImpl) target;
                    genericDaoImpl.setType(at.getAnnotation(Dao.class).value());
                    return proxy.invokeSuper(target, args);
               }
          });
          
          final Class proxyClass = e.create().getClass();
          
          AnnotatedTypeBuilder builder = AnnotatedTypeBuilder.newInstance(proxyClass)
                    .readAnnotationsFromUnderlyingType();
                    
          BeanBuilder beanBuilder = new BeanBuilder(builder.create(), bm);
          beanBuilder.defineBeanFromAnnotatedType();
          beanBuilder.setBeanLifecycle(new BeanLifecycleImpl() {

               @Override
               public Object create(BeanImpl bean, CreationalContext creationalContext) {
                     Object instance = e.create();
                     bean.getInjectionTarget().inject(instance, creationalContext);
                     bean.getInjectionTarget().postConstruct(instance);
                     return instance;
               }

          });

          beanBuilder.getQualifiers().add(new AnnotationLiteral<Default>(){});
          Bean bean = beanBuilder.create();
          
          additionalBeans.add(bean);
     }


     void afterBeanDiscovery(@Observes AfterBeanDiscovery abd) {
          for (Bean<?> bean : additionalBeans) {
               abd.addBean(bean);
          }
     }
     


}

Arquillian test:

@RunWith(Arquillian.class)
public class LambicoTest {

     @Deployment
     public static Archive<?> createTestArchive() {
          Archive<?> archive = ShrinkWrap.create("test.jar", JavaArchive.class)
        .addPackages(true, LambicoTest.class.getPackage())
        .addManifestResource("META-INF/beans.xml")
        .addServiceProvider(Extension.class,  LambicoExtension.class);
     
          return archive;
     }

     @Inject MyDao dao;

     @Test
     public void test() {
          User user = dao.load(2L);
          System.out.println(user);
     }

}