Crear un algoritmo de ordenación por inserción (Insertion Sort).

Aquí te muestro un ejemplo de cómo implementar el algoritmo de ordenación por inserción en Go:

```go
package main

import (
	"fmt"
	"sort"
)

// insertionSort ordena un slice de enteros utilizando el algoritmo de ordenación por inserción.
func insertionSort(arr []int) {
	for i := 1; i < len(arr); i++ {
		key := arr[i]
		j := i - 1
		for j >= 0 && arr[j] > key {
			arr[j+1] = arr[j]
			j--
		}
		arr[j+1] = key
	}
}

// insertionSortConRecursion ordena un slice de enteros utilizando el algoritmo de ordenación por inserción con recursividad.
func insertionSortConRecursion(arr []int, n int) {
	if n <= 1 {
		return
	}
	insertionSortConRecursion(arr, n-1)
	key := arr[n-1]
	j := n - 2
	for j >= 0 && arr[j] > key {
		arr[j+1] = arr[j]
		j--
	}
	arr[j+1] = key
}

func main() {
	// Ejemplo de uso del algoritmo de ordenación por inserción
	arr := []int{5, 2, 8, 3, 1, 6, 4}
	fmt.Println("Arreglo original:", arr)
	insertionSort(arr)
	fmt.Println("Arreglo ordenado:", arr)

	// Ejemplo de uso del algoritmo de ordenación por inserción con recursividad
	arr2 := []int{5, 2, 8, 3, 1, 6, 4}
	fmt.Println("\nArreglo original:", arr2)
	insertionSortConRecursion(arr2, len(arr2))
	fmt.Println("Arreglo ordenado:", arr2)

	// Comparación con la función de ordenación de la biblioteca sort
	arr3 := []int{5, 2, 8, 3, 1, 6, 4}
	fmt.Println("\nArreglo original:", arr3)
	sort.Ints(arr3)
	fmt.Println("Arreglo ordenado:", arr3)
}
```

Este código define dos funciones: `insertionSort` y `insertionSortConRecursion`. La primera función utiliza un bucle for para ordenar el arreglo, mientras que la segunda función utiliza recursividad para ordenar el arreglo.

En el ejemplo de uso, se crea un arreglo de enteros y se ordena utilizando cada una de las funciones. También se compara con la función de ordenación de la biblioteca sort.

La salida del programa será:

```
Arreglo original: [5 2 8 3 1 6 4]
Arreglo ordenado: [1 2 3 4 5 6 8]

Arreglo original: [5 2 8 3 1 6 4]
Arreglo ordenado: [1 2 3 4 5 6 8]

Arreglo original: [5 2 8 3 1 6 4]
Arreglo ordenado: [1 2 3 4 5 6 8]
```

Es importante destacar que el algoritmo de ordenación por inserción tiene una complejidad temporal de O(n^2) en el peor caso, lo que lo hace menos eficiente que otros algoritmos de ordenación como el quicksort o el mergesort para grandes conjuntos de datos. Sin embargo, puede ser útil para pequeños conjuntos de datos o para situaciones en las que la simplicidad del algoritmo es más importante que la eficiencia.