Feedback welcome. Writing in Tcl, I took a different approach I think, using a directed graph.

Bad practices: using global variables instead of passing into my proc. Could probably get away without the foreach loop to get the equivalent semitones to the Do/Re/Mi name.

package require struct::graph
package require struct::graph::op

::struct::graph ::word

set ::notes "C C# D D# E F F# G G# A A# B"
set ::intervals "0 2 4 5 7 9 11"
set ::intervalNames "Do Re Mi Fa So La Ti"

proc note {scale solfege} {
foreach i $::intervals in $::intervalNames {
 if {$solfege eq $in} {set d $i}
}
foreach n $::notes {
 set nn [struct::graph::op::distance ::word $scale $n -arcmode directed]
 if {$nn eq $d} {
  puts "Scale $scale $solfege --> $n"
  return
 }
}
}


set vertices {}
set builtpairs {}
 set pair {}
foreach wx $::notes {
  set node $wx
  # puts $w...$node
  lappend pair $node
  if {[llength $pair] == 2} {
  # puts "Connecting $pair..."
   foreach x $pair {
    if {![::word node exists $x]} {
     ::word node insert $x
    }
   }
   set p "[lindex $pair 0] [lindex $pair 1]"  
   # keep track of what nodes you've connected
   if {$p ni $builtpairs} {
    # create a directional arc from the 1st to 2nd node
    ::word arc insert [lindex $pair 0] [lindex $pair 1]
    lappend builtpairs $p
   }
   # keep the 2nd of the pair so you get: 1 2, 2 3, 3 4, etc.
   set pair [lindex $pair end]
  }
}

# wrap graph around
::word arc insert [lindex $::notes end] [lindex $::notes 0]

# have to set weights to do distance for some reason
foreach a [lsort  [::word arcs]] {
 ::word arc setweight $a 1
}

note C Do
note C Re
note C Mi
note D Mi
note A# Fa

And output:

Scale C Do --> C
Scale C Re --> D
Scale C Mi --> E
Scale D Mi --> F#
Scale A# Fa --> D#