Earlier quoted context omitted.
Your "That's WRONG" is, pardon the capitalization, WRONG. The definition of BB(100) is the number below which all 100-rule TMs that halt will in fact halt. Everything that ever halts will halt before that number of steps, everything that continues one step past BB(100) will never halt. That's the definition . If you have a conjecture encoded into a 100-state TM and you know BB(100), then all you do is run the machine…
I see what you are saying, but think of it in reverse: If the only way to prove or disprove Goldbach’s conjecture is to try every integer forever until you find a counter example (i.e. you can never stop - there is no point at which you can say, I checked enough numbers). Then the same would apply to calculating BB(100) - you can never actually calculate the value of it - you never know if you have run it long enough…
That's not true. The Busy Beaver function is a counterexample: it's possible to enumerate all n-rule Turing machines. Each such machine either halts after a finite number of steps or does not. We can list the number of steps that all the halting n-rule machines take to stop, and the largest number that we list is BB(n). That's defined.
I think your problem is that you don't understand what "computable" means. When we say that the Busy Beaver function is uncomputable, we mean that there is no halting algorithm that takes any natural number n as its input and always returns BB(n). There are algorithms that return BB(n) for any specific n: "return [BB(n)]" is an example.
The reason that no general (finite) algorithm exists that can compute the Busy Beaver function is this: there are some Turing machines that never halt but that cannot be proven to never halt; that is, there is no sequence of symbols and accompanying interpretive framework that proves that such a machine never halts. BUT THEY STILL DON'T HALT. So when our algorithm tries to compute BB(k), and there's a k-rule TM in the class that I described, the algorithm freaks out. It has no way of knowing that it should ignore this TM, because it's mathematically impossible to know that. But it can't wait forever either. So it watches the weird TM for an infinite amount of time. The only way to get around this is to hard-code in special case handling for these weird TMs; but you can only do that a finite number of times ('cause the algorithm's finite), and the class of weird TMs has no finite description.
To the person whose comment is above or below mine: that's the difference between BB(1 - 4) and BB(100). There are no weird TMs with less than 5 rules. But there are almost certainly some with 100 rules.