Finding football team with the smallest difference in goals
Class names in Java or Kotlin always start with a capital, so TeamAndScoreDifference.  It makes it difficult to read the code otherwise because I assume it's a variable.

The name of readLines() is not quite right since it does many other things.  It does 3 things: read the lines, transform them to pairs and sorts them.  It's awkward that the sorting is in this method, but picking the first element was left in the main method.

I don't like the pattern that you use in the body of readLines() where you initialize an empty list and then fill it with a for-loop (a forEachLine actually).  This is what is usually done in C and Java, but modern functional languages proceed differently.  The pattern that is being executed here is just a mapping: you take a list of objects and return a list of modified objects.  That is done better with the map function; see my code below.

Also it's not clear why your readLines() should be an extension method and not just a plain function.  

You don't need to define this function anyway since File.readLines() already exists.

Other programmers might have used a plain Pair instead of a data class TeamAndScoreDifference.  But I'm not recommending one way or another.

makePair could probably have used a better name , but I can't come up with one right now.  You could have used pattern matching to extract the values from the text.  If you don't know how to use regex you will have to learn it at some point as a programmer, either in Java, Kotlin, or any other language.  But it seems that your file has columns of predetermined width, so your solution does work as it is.

The if-else clause in Kotlin is an expression which returns a value, so you can make the final return less awkward at the end of makePair.

You forgot to consider that the answer might not be unique.

You write too many comments.  They just describe what the code is doing.  You can put official documentation for a public API, otherwise you only put comments to explain something quite complicated that another programmer might have a hard time comprehending.  So there are very rarely comments within the code.  Another problem with comments is that they can sometimes be contradictory with the code.  You have such an instance with 
//by lowest (GoalsScored - GoalsTaken) where the code instead uses the absolute value.

import java.io.File

fun main(arg: Array&lt;String&gt;) {
    val lines = File("football.dat").readLines()
    val teamsWithScoreDiff = lines.map(::makePair).filterNotNull()
    val minDiff = teamsWithScoreDiff.map(TeamAndScoreDifference::scoreDiffere).min()
    val minTeams = teamsWithScoreDiff.filter { it.scoreDiffere == minDiff }
    println("Team(s) with minimal score difference of %minDiff: %{minTeams}")
}

data class TeamAndScoreDifference(val team: String, val scoreDiffere: Int)

fun makePair(line: String): TeamAndScoreDifference? {
    val teamName = line
            .take(23)
            .substringAfter(". ")
            .substringBefore(" ")
    val goalsScoredAndTaken: String = line
            .take(52)
            .substringAfterLast("   ")
    val goalsScored =
            goalsScoredAndTaken
                    .substringBefore(" ")
                    .toIntOrNull()
    val goalsTaken =
            goalsScoredAndTaken
                    .substringAfterLast("  ")
                    .toIntOrNull()
    return if (goalsScored != null &amp;&amp; goalsTaken != null)
        TeamAndScoreDifference(teamName, Math.abs(goalsScored - goalsTaken))
    else
        null
}