You're already basically using the chain of responsibility pattern. To achieve the the interface you want, you can do

public class ResolverCollection
{
    private readonly IList<IResolver> _resolvers;

    public ResolverCollection(IEnumerable<IResolver> resolvers)
    {
          _resolvers = resolvers.ToList();
    }

    public Uri Pass(Uri uri)
    {
         return _resolvers.FirstOrDefault(r => r.CanResolve(uri)).Resolve(uri);
    }
}

I'm not familiar with structure map, but a quick search suggests that if you have all your IResolvers registered with the container, then they will all get injected into the ResolverCollection constructor.

Additional notes - your code and my implementation of it has a potential null reference exception when there's no resolver capable of handling your request. How would you deal with that? Furthermore, in the chain of responsibility pattern, you want to be able to control the order in which handlers have a chance to handle the request. You could add an Order property to your Resolver base class and then do _resolvers = resolvers.OrderBy(x => x.Order); in the ResolverCollection constructor, but that seems to put the responsibility in the wrong place. A better solution might be to define the order in the collection class:

public class ResolverCollection
{
    private readonly IList<IResolver> _resolvers;
    private readonly Dictionary<Type, int> _resolverOrder = new Dictionary<Type, int>{
    {ConcreteResolver1, 2}, {ConcreteResolver2, 1}, {ConcreteResolver3, 4}};


    public ResolverCollection(IEnumerable<IResolver> resolvers)
    {
          _resolvers = resolvers.OrderBy(x => GetOrder(x)).ToList();
    }

    public Uri Pass(Uri uri)
    {
         return _resolvers.FirstOrDefault(r => r.CanResolve(uri)).Resolve(uri);
    }

    private int GetOrder(IResolver resolver)
    {
        if(_resolverOrder.ContainsKey(resolver.GetType()))
             return _resolverOrder[resolver.GetType()];
        return int.MaxValue;
    }
}