Main-problems probably in " vs " command and final output printing (see code).

Also, adding a more "advanced" solution demonstrated by SoftUni instructors that works with class object. Super helpful if you look through it.

Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
 
namespace _3._MOBA_Challenger
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, Dictionary<string, int>>
                trackPlayers = new Dictionary<string, Dictionary<string, int>>();
            Dictionary<string, int> playerSkills = new Dictionary<string, int>();
 
            while (true)
            {
                {
                    string line = Console.ReadLine();
 
                    if (line == "Season end")
                    {
                        break;
                    }
 
                    if (line.Contains(" -> "))
                    {
                        string[] parts = line.Split(" -> ");
                        string player = parts[0];
                        string position = parts[1];
                        int skills = int.Parse(parts[2]);
 
                        if (!trackPlayers.ContainsKey(player))
                        {
                            trackPlayers.Add(player, new Dictionary<string, int>());
                            trackPlayers[player].Add(position, skills);
                            playerSkills.Add(player, skills);
                        }
                        else
                        {
                            {
                                if (!trackPlayers[player].ContainsKey(position))
                                {
                                    trackPlayers[player].Add(position, skills);
                                    playerSkills[player] += skills;
                                }
                                else
                                {
                                    int oldSkill = trackPlayers[player][position];
 
                                    if (skills > oldSkill)
                                    {
                                        trackPlayers[player][position] = skills;
                                        int diff = skills - oldSkill;
                                        playerSkills[player] += diff;
                                    }
                                }
                            }
                        }
                    }
 
                    if (line.Contains(" vs "))
                    {
                        string[] playersDuel = line.Split(" vs ");
                        string player1 = playersDuel[0];
                        string player2 = playersDuel[1];
 
                        if (trackPlayers.ContainsKey(player1) && trackPlayers.ContainsKey(player2))
                        {
                            string playerToRemove = "";
                            foreach (var role in trackPlayers[player1]) // better skillPlayer1
                            {
                                foreach (var pos in trackPlayers[player2]) // better skillPlayer2
                                {
                                    if (role.Key == pos.Key)
                                    {
                                        if (trackPlayers[player1].Values.Sum() > trackPlayers[player2].Values.Sum())
                                        {
                                            playerToRemove = player2;
                                        }
                                        else if (trackPlayers[player1].Values.Sum() <
                                                 trackPlayers[player2].Values.Sum())
                                        {
                                            playerToRemove = player1;
                                        }
                                    }
                                }
 
                                trackPlayers.Remove(playerToRemove);
                                // break;
                                // add break after removing from collection,
                                // otherwise will cause exception when modifying collection
                                // during foreach 
                            }
                        }
                    }
                }
            }
            // At that point you should print the players, ordered by total skill in desecending order, 
            // then ordered by player name in ascending order.  (missing here ??)
            // foreach (var player in playerSkills.OrderByDescending(x => x.Value))
            foreach (var player in playerSkills.OrderByDescending(x => x.Value).ThenBy(x => x.Key))
            {
                string name = player.Key;
                int totalSkills = player.Value;
                Console.WriteLine($"{name}: {totalSkills} skill");
 
                // Foreach player print their position and skill, ordered desecending by skill, 
                // then ordered by position name in ascending order (missing here ??)
                // foreach (var roleSkill in trackPlayers[name].OrderByDescending(x => x.Value))
                foreach (var roleSkill in trackPlayers[name].OrderByDescending(x => x.Value).ThenBy(x => x.Key))
                {
                    string role = roleSkill.Key;
                    int skill = roleSkill.Value;
                    Console.WriteLine($"- {role} <::> {skill}");
                }
            }
        }
    }
}

SoftUni-Instructors Demo:

using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.Immutable;

namespace MOBAChallenger_withClass
{
    public class Program
    {
        private static void Main()
        {
            var dictNamePlayer = new Dictionary<string, Player>();
            string command;
            while ((command = Console.ReadLine()) != "Season end")
            {
                if (!command.Contains("vs"))
                {
                    var commandArray = command.Split(" -> ");
                    var playerName = commandArray[0];
                    var position = commandArray[1];
                    var skill = int.Parse(commandArray[2]);

                    if (!dictNamePlayer.ContainsKey(playerName))
                    {
                        var newPlayer = new Player(playerName);
                        dictNamePlayer.Add(playerName, newPlayer);
                    }

                    dictNamePlayer[playerName].AddOrUpdatePosition(position, skill);
                }
                else
                {
                    var commandArray = command.Split(' ');
                    var firstPlayer = commandArray[0];
                    var secondPlayer = commandArray[2];

                    if (!dictNamePlayer.ContainsKey(firstPlayer) || !dictNamePlayer.ContainsKey(secondPlayer))
                    {
                        continue;
                    }

                    var playerOne = dictNamePlayer[firstPlayer];
                    var playerTwo = dictNamePlayer[secondPlayer];

                    if (playerOne.GetTotalSkillPoints() == playerTwo.GetTotalSkillPoints())
                    {
                        continue;
                    }

                    var duelsCount = playerOne.GetPositions()
                        .Intersect(playerTwo.GetPositions())
                        .Count();

                    if (duelsCount <= 0)
                    {
                        continue;
                    }

                    dictNamePlayer.Remove(playerOne.GetTotalSkillPoints() > playerTwo.GetTotalSkillPoints()
                        ? playerTwo.Name
                        : playerOne.Name);
                }
            }

            PrintResult(dictNamePlayer.Values.ToList());
        }

        private static void PrintResult(IEnumerable<Player> players)
        {
            foreach (var player in players
                .OrderByDescending(player => player.GetTotalSkillPoints())
                .ThenBy(player => player.Name))
            {
                Console.WriteLine($"{player.Name}: {player.GetTotalSkillPoints()} skill");

                foreach (var (position, skill) in player
                    .GetPositionsAndSkillsDictionary()
                    .OrderByDescending(x => x.Value)
                    .ThenBy(x => x.Key))
                {
                    Console.WriteLine($"- {position} <::> {skill}");
                }
            }
        }

        private class Player
        {
            public string Name { get; }

            private readonly Dictionary<string, int> _dictPositionSkill;

            public Player(string name)
            {
                Name = name;
                _dictPositionSkill = new Dictionary<string, int>();
            }

            public void AddOrUpdatePosition(string position, int skill)
            {
                if (!_dictPositionSkill.ContainsKey(position))
                {
                    _dictPositionSkill.Add(position, skill);
                }
                else if (_dictPositionSkill[position] < skill)
                {
                    _dictPositionSkill[position] = skill;
                }
            }

            public IEnumerable<string> GetPositions()
            {
                return _dictPositionSkill.Keys;
            }

            public ImmutableDictionary<string, int> GetPositionsAndSkillsDictionary()
            {
                return _dictPositionSkill.ToImmutableDictionary();
            }

            public int GetTotalSkillPoints()
            {
                return _dictPositionSkill.Values.Sum();
            }
        }
    }
}