Yes, its a simple dfs like:

// node is the current node of the tree the dfs is visiting
// index the current index of t
// mismatches is the number of mismatches I had found to get into the node
void dfs(node, index, mismatches) {
 if ( index == |t| ) {
  // means i traverse all t
  // count(node) = number of leafs of subtree rooted at node ( O(1) after preprocessing)
  // ans[x] = number of substrings of s that can be matched to t changing exactly x chars
  ans[mismatches] += count(node);
  ret;
 }
 // node contains a substring of s
 // node.begin is start index (inclusive)
 // node.end is end index (exclusive)
 for (i = node.begin; i < node.end && index < |t|; i++, index++) {
 // traverse substring at node until we reach end of t or end of node
  if ( s[i] == '$' )
   ret; // a delimiter means node has not enough chars to match t
  // count mismatches while traversing substring at node
  mismatched += s[i] == t[index] ? 1 : 0;
 }

 // traverse children
 for each children of node called next
  dfs(next, index, mismatched);

 // i had traversed the whole t
 if ( node is a leaf )
  ans[mismatched]++;
}

I can't see it but multiplying these polynomials is going to give the hamming distance for each substring of s? if yes, thats wonderful.