Dictionary or custom Collection
I think you are too concerned with the implementation right now. 

The last part of the question 


  ... recommended ... for scalability and unit-testability?


is the most important one.

Let's imaging you were to write the test for this feature. You would start off by designing the API that the user of the functionality would ultimately consume. Secondly as far as the tests go ... they could careless how it is implemented 'under the hood' it only cares that it meets the requirements performance just being on possible requirement. Many times asymptotic complexity doesn't even play a critical role unless n is large. Take for example Strassen matrix multiplication it is only practical for larger matrices.

For scalability I'm assuming you mean maintainability and extensibility. The best way to achieve that is to use the dependency inversion principle (DIP) so that you are not depending on either a list or a dict but instead on the correct abstraction.

One possible abstraction is that the rules represent a validation.

interface IValidator&lt;T&gt;
{
   bool IsValid(T item);
}


Your test would look as follows.

[Test]
void NoRulesEverythingIsFalse()
{
    var rules = new Rules();
    Assert.False(rules.IsValid(""));
}

[Test]
void SingleRule()
{
    var rules = new Rules(new[] 
    {
        new LinkedRule("abc", "Only abc is allowed.")
    });
    Assert.True(rules.IsValid("abc"));
    Assert.AreEqual(
        rules.GetLinkForRule("abc"),
        "Only abc is allowed.");
    Assert.False(rules.IsValid("123"));
}


Now with this you can implement it however you want as long as your test pass. Feel free to add a performance test if it is required.

// LinkedRule.cs
struct LinkedRule {
    string Rule { get; set; }
    string Link { get; set; }
}


// Rules.cs
class Rules : IValidator&lt;string&gt;
{
    private Dictionary&lt;string, LinkedRule&gt; RulesToLinks { get; }

    public RuleValidator(IEnumerable&lt;LinkedRule&gt; linkedRules)
    {
        RulesToLinks = linkedRules.ToDictionary(
            x =&gt; x.Rule);
    }

    public bool IsValid(string rule) =&gt;
        RulesToLinks.Keys.Contains(rule);

    public string GetLinkForRule(string rule) =&gt; RulesToLinks[rule];

    // ...
}