Methods to create C# dictionaries, with static keys/values, in fluent notation

This sounds like a good idea but I don't think it is, at least not with the current method names that I agree with @denis are very confusing.

The name KeysToValue should actually be AddValueWithKeys because this is the order of parameters and it better suggests that the first parameter is a value and not a key. KeysToValue sounds like a query that gets something or converts keys to values etc.

I also find the extension should extend the dictionary and not some arbitrary IEnumerable<KeyValuePair<TKey, TValue>> because if it will throw a duplicate key exception, it will be hard to find where it happened and it's of more use if extending a dictionary. If it however extends the IEnumerable then the name should be Concat.

The improved version could look like this:

public static Dictionary<TKey, TValue> AddValueWithKeys<TKey, TValue>(
    this Dictionary<TKey, TValue> dictionary, 
    TValue value, 
    params TKey[] keys)
{
    foreach (var key in keys) dictionary.Add(key, value);
    return dictionary;
}

and is much easier to use as it now requries only a single extension

public static readonly IReadOnlyDictionary<string, string> GroupsForVehicles =
    new Dictionary<string, string>()
        .AddValueWithKeys(RoadVehicles, "Car", "Truck", "Tractor", "Motorcycle");

Your Dictionary<,> instantiation doesn't looks fluent to me at all, instead it looks overly-coupled with all kinds of extension method calls and it's kinda counter intuitive as the first element in a KeyValuePair<,> is usually the key, but in your case it's the value/s.

It's also hard to tell if all of those "Car", "Truck", "Tractor", "Motorcycle" will be connected in a way to your key or wait.. those were the keys..

I would suggest to create a separate class, which cleans up that for you:

public class FluentDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    private readonly Dictionary<TKey, TValue> _dictionary;

    public ICollection<TKey> Keys => _dictionary.Keys;
    public ICollection<TValue> Values => _dictionary.Values;

    public int Count => _dictionary.Count;
    public bool IsReadOnly => false;

    public TValue this[TKey key]
    {
        get { return _dictionary[key]; }
        set { _dictionary[key] = value; }
    }

    public FluentDictionary()
    {
        _dictionary = new Dictionary<TKey, TValue>();
    }

    public FluentDictionary(Dictionary<TKey, TValue> source)
    {
        _dictionary = source;
    }

    public FluentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> source)
    {
        _dictionary = source.ToDictionary(pair => pair.Key, pair => pair.Value);
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _dictionary.GetEnumerator();

    public void Add(TKey key, TValue value) => _dictionary.Add(key, value);

    public void Add(KeyValuePair<TKey, TValue> item) => Add(item.Key, item.Value);

    public void Add(TKey[] keys, TValue value)
    {
        foreach (var key in keys)
        {
            Add(key, value);
        }
    }

    public void Clear() => _dictionary.Clear();

    bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
    {
        TValue value;
        return _dictionary.TryGetValue(item.Key, out value) &&
                EqualityComparer<TValue>.Default.Equals(value, item.Value);
    }

    void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        ICollection<KeyValuePair<TKey, TValue>> collection = new List<KeyValuePair<TKey, TValue>>(_dictionary);
        collection.CopyTo(array, arrayIndex);
    }

    bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
    {
        return this.Contains(item) && Remove(item.Key);
    }

    public bool ContainsKey(TKey key) => _dictionary.ContainsKey(key);

    public bool Remove(TKey key) => _dictionary.Remove(key);

    public bool TryGetValue(TKey key, out TValue value) => _dictionary.TryGetValue(key, out value);
}

Some extra functionality you might want to have is a way of obtaining all of the keys that point to specific value:

public TKey[] FindKeysMatchingValue(TValue value) => _dictionary.Where(
        pair => EqualityComparer<TValue>.Default.Equals(pair.Value, value))
    .Select(pair => pair.Key)
    .ToArray();

I like your idea, but instead of ending the sequence of KeysToValue() calls with a call to ToDictionary(), I would make an Add-extension to IDictionary like below. You then only need one extension, and it is more flexible:

  public static class FluentDictionaries
  {
    public static IDictionary<TKey, TValue> Add<TKey, TValue>(this IDictionary<TKey, TValue> dict, TValue value, params TKey[] keys)
    {
      Array.ForEach(keys, k => dict.Add(k, value));
      return dict;
    }

    public static IReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dict)
    {
      return dict as IReadOnlyDictionary<TKey, TValue>;
    }

  }

Use case:

static void Main(string[] args)
{
  string RoadVehicles = "RoadVehicles";
  string RailVehicles = "RailVehicles";
  string Watercraft = "Watercraft";
  string Aircraft = "Aircraft";

  IReadOnlyDictionary<string, string> GroupsForVehicles = new Dictionary<string, string>()
      .Add(RoadVehicles, "Car", "Truck", "Tractor", "Motorcycle")
      .Add(RailVehicles, "Locomotive", "Railcar", "Powercar", "Handcar")
      .Add(Watercraft, "Ship", "Sailboat", "Rowboat", "Submarine")
      .Add(Aircraft, "Jetplane", "Propellerplane", "Helicopter", "Glider", "Balloon")
      .AsReadOnly();

  foreach (var key in GroupsForVehicles.Keys.OrderBy(key => key))
  {
    Console.WriteLine(key + ": " + GroupsForVehicles[key]);
  }
}