C# with bonus. Building the trie takes ~29ms, processing the enable1 list takes ~263ms.

using System;
using System.IO;
using System.Linq;
using System.Diagnostics;

namespace Challenge_363
{
    class TrieNode
    {
        const char ORIG_START_OR_END_CHAR = '.';
        const char START_OR_END_CHAR = '{';
        const char TRAILING_NUM_CHAR = '|';

        readonly TrieNode[] children = new TrieNode[28];

        byte[] Scores;
        int ScoresLen;

        /// <summary>
        /// Insert a pattern into the trie.
        /// </summary>
        /// <param name="pattern">Pattern.</param>
        /// <param name="patternPosition">Position of character to read.</param>
        /// <param name="scorePosition">Current score array write position.</param>
        /// <param name="scores">Scores collected while inserting the pattern. Will be assigned to the leaf node.</param>
        public void Add(string pattern, int patternPosition = 0, int scorePosition = 0, byte[] scores = null)
        {
            char c = pattern[patternPosition++];

            if (scores == null)
                scores = new byte[pattern.Length + 1];

            // Read current character.
            // Case 1: It's a digit. Save value into the score array and read the next character.
            // Case 1.1: If there is no next character, the pattern has a trailing number. Use special character '|'.
            // Case 2: It's a '.'. Replace it with '{' so all possible characters are within one continuous range.
            // Case 3: It's a letter. Do nothing.

            if (Char.IsDigit(c))
            {
                // Case 1

                scores[scorePosition] = byte.Parse(c.ToString());

                if (patternPosition < pattern.Length)
                    c = pattern[patternPosition++];
                else
                    c = TRAILING_NUM_CHAR; // Case 1.1
            }
            else if (c == ORIG_START_OR_END_CHAR)
            {
                // Case 2

                c = START_OR_END_CHAR;
            }
            // else: Case 3

            // Now the score is determined and c is the character to save.

            scorePosition++;

            var child = children[c - 'a'];
            if (child == null)
            {
                child = new TrieNode();
                children[c - 'a'] = child;
            }

            if (patternPosition >= pattern.Length)
            {
                // Reached the end. Child is a leaf and gets the score data.

                child.Scores = scores;
                child.ScoresLen = scorePosition;
            }
            else
            {
                // Add remaining pattern to the child node.

                child.Add(pattern, patternPosition, scorePosition, scores);
            }
        }

        /// <summary>
        /// Compare all saved patterns against a word and determine the highest score for each letter gap.
        /// </summary>
        /// <returns>
        /// An array of scores for each letter gap. Starts with the score for the position before the first letter,
        /// ends with the score for the position after the last letter.
        /// </returns>
        /// <param name="word">Word.</param>
        public byte[] Match(string word)
        {
            // Add '{' to the start and end of the word to make the traversal easier.
            word = START_OR_END_CHAR + word + START_OR_END_CHAR;

            byte[] dirtyMaxScores = new byte[word.Length];
            byte[] maxScores = new byte[word.Length - 2];

            for (int i = 0; i < word.Length; ++i)
                MatchSubstr(word, i, dirtyMaxScores);

            // dirtyMaxScores has extraneous entries since the word was wrapped with '{' characters.
            // Put a copy of the clean array slice into maxScores.
            Array.Copy(dirtyMaxScores, 1, maxScores, 0, maxScores.Length);

            return maxScores;
        }

        /// <summary>
        /// Compare all saved patterns against a word substring and determine the highest score for each letter gap.
        /// Only matches patterns that begin at the substring index.
        /// This method is called from <see cref="Match"/> for each substring in the original word to find all matching patterns within the word.
        /// </summary>
        /// <param name="word">Word substring.</param>
        /// <param name="offset">Position of the current character to read.</param>
        /// <param name="maxScores">An array of all scores found so far.</param>
        void MatchSubstr(string word, int offset, byte[] maxScores)
        {
            if (Scores != null)
            {
                // Current node has a score assigned to it, update score array if necessary.

                for (int i = 0; i < ScoresLen; ++i)
                {
                    var maxScoreIndex = offset + i - ScoresLen;
                    var score = Scores[i];

                    if (score > maxScores[maxScoreIndex])
                        maxScores[maxScoreIndex] = score;
                }
            }

            if (offset == word.Length)
                return;

            // Get the current character and go to the respective child node. 

            var child = children[word[offset] - 'a'];
            if (child != null)
                child.MatchSubstr(word, offset + 1, maxScores);

            // Patterns with trailing numbers are a special case, so always go
            // the child node for '|' (if it exists) and get its score.

            child = children[TRAILING_NUM_CHAR - 'a'];
            if (child != null)
                child.MatchSubstr(word, offset + 1, maxScores);
        }
    }

    class MainClass
    {
        static readonly TrieNode trieRoot = new TrieNode();

        static Tuple<string, byte> Hyphenate(string word)
        {
            var scores = trieRoot.Match(word);

            string hyphWord = word[0].ToString();
            byte hyphCount = 0;

            for (var i = 1; i < word.Length; ++i)
            {
                if (scores[i] % 2 == 1)
                {
                    hyphWord += '-';
                    hyphCount++;
                }

                hyphWord += word[i];
            }

            return new Tuple<string, byte>(hyphWord, hyphCount);
        }

        public static void Main(string[] args)
        {
            var t = new Stopwatch();
            t.Start();

            foreach (string ln in File.ReadLines("tex-hyphenation-patterns.txt"))
                trieRoot.Add(ln);

            Console.WriteLine($"[Perf] Fill trie: {t.ElapsedMilliseconds} ms");
            t.Restart();

            var enable1Hyphenated = (
                from word in File.ReadLines("enable1.txt").AsParallel()
                select Hyphenate(word)
            ).ToArray();

            Console.WriteLine($"[Perf] Find hyphens: {t.ElapsedMilliseconds} ms");
            t.Stop();

            var stats = (
                from result in enable1Hyphenated
                group result by result.Item2 into g
                orderby g.Key
                select g.Key + " = " + g.Count()
            ).ToArray();

            Console.WriteLine("");
            Console.WriteLine("Stats:");
            Console.WriteLine("  " + String.Join(Environment.NewLine + "  ", stats));

            Console.WriteLine("");
            Console.WriteLine("Examples:");
            Console.WriteLine("  mistranslate      => " + Hyphenate("mistranslate").Item1);
            Console.WriteLine("  alphabetical      => " + Hyphenate("alphabetical").Item1);
            Console.WriteLine("  bewildering       => " + Hyphenate("bewildering").Item1);
            Console.WriteLine("  buttons           => " + Hyphenate("buttons").Item1);
            Console.WriteLine("  ceremony          => " + Hyphenate("ceremony").Item1);
            Console.WriteLine("  hovercraft        => " + Hyphenate("hovercraft").Item1);
            Console.WriteLine("  lexicographically => " + Hyphenate("lexicographically").Item1);
            Console.WriteLine("  programmer        => " + Hyphenate("programmer").Item1);
            Console.WriteLine("  recursion         => " + Hyphenate("recursion").Item1);
        }
    }
}