try to implement feature(more_qualified_paths)

This handles
```rust
let <T as Trait>::Assoc { a } = <T as Trait>::Assoc { a: 0 };
```

Author: WaffleLapkin

crates/hir-ty/src/infer.rs

@@ -1731,6 +1731,88 @@ impl<'db> InferenceContext<'db> {
 
                 self.resolve_variant_on_alias(ty, unresolved, mod_path)
             }
+            TypeNs::TraitId(_trait_id) => {
+                let Some(mut remaining_idx) = unresolved else {
+                    drop(ctx);
+                    return (self.err_ty(), None);
+                };
+
+                let mut remaining_segments = path.segments().skip(remaining_idx);
+
+                let mut ty;
+
+                // We need to try resolving unresolved segments one by one because each may resolve
+                // to a projection, which `TyLoweringContext` cannot handle on its own.
+                let mut tried_resolving_once;
+                loop {
+                    let resolved_segment = path.segments().get(remaining_idx - 1).unwrap();
+                    let current_segment = remaining_segments.take(1);
+
+                    // `lower_partly_resolved_path()` returns `None` as type namespace unless
+                    // `remaining_segments` is empty, which is never the case here. We don't know
+                    // which namespace the new `ty` is in until normalized anyway.
+                    (ty, _) = ctx.lower_partly_resolved_path(
+                        node,
+                        resolution,
+                        resolved_segment,
+                        current_segment,
+                        (remaining_idx - 1) as u32,
+                        false,
+                    );
+                    tried_resolving_once = true;
+
+                    ty = self.table.insert_type_vars(ty);
+                    ty = self.table.normalize_associated_types_in(ty);
+                    ty = self.table.resolve_ty_shallow(&ty);
+                    if ty.is_unknown() {
+                        return (self.err_ty(), None);
+                    }
+
+                    // FIXME(inherent_associated_types): update `resolution` based on `ty` here.
+                    remaining_idx += 1;
+                    remaining_segments = remaining_segments.skip(1);
+
+                    // If we can resolve to an enum variant, it takes priority over associated type
+                    // of the same name.
+                    if let Some((AdtId::EnumId(id), _)) = ty.as_adt() {
+                        let enum_data = self.db.enum_data(id);
+                        let name = current_segment.first().unwrap().name;
+                        if let Some(variant) = enum_data.variant(name) {
+                            return if remaining_segments.len() == 1 {
+                                (ty, Some(variant.into()))
+                            } else {
+                                // We still have unresolved paths, but enum variants never have
+                                // associated types!
+                                (self.err_ty(), None)
+                            };
+                        }
+                    }
+
+                    if tried_resolving_once {
+                        // FIXME: with `inherent_associated_types` this is allowed, but our `lower_partly_resolved_path()`
+                        // will need to be updated to err at the correct segment.
+                        //
+                        // We need to stop here because otherwise the segment index passed to `lower_partly_resolved_path()`
+                        // will be incorrect, and that can mess up error reporting.
+                        break;
+                    }
+
+                    if remaining_segments.is_empty() {
+                        break;
+                    }
+                }
+                drop(ctx);
+
+                let variant = ty.as_adt().and_then(|(id, _)| match id {
+                    AdtId::StructId(s) => Some(VariantId::StructId(s)),
+                    AdtId::UnionId(u) => Some(VariantId::UnionId(u)),
+                    AdtId::EnumId(_) => {
+                        // FIXME Error E0071, expected struct, variant or union type, found enum `Foo`
+                        None
+                    }
+                });
+                (ty, variant)
+            }
             TypeNs::AdtSelfType(_) => {
                 // FIXME this could happen in array size expressions, once we're checking them
                 (self.err_ty(), None)
@@ -1741,7 +1823,6 @@ impl<'db> InferenceContext<'db> {
             }
             TypeNs::AdtId(AdtId::EnumId(_))
             | TypeNs::BuiltinType(_)
-            | TypeNs::TraitId(_)
             | TypeNs::TraitAliasId(_)
             | TypeNs::ModuleId(_) => {
                 // FIXME diagnostic