We have a set of jobs $J_i = (a_i, b_i)$ where all the $a_i,b_i \ge 0$. We want to find the permutation $\pi$ which minimises $$\max_j \left\{ b_{\pi(j)} + \sum_{k \le j}a_{\pi(k)} \right\}$$
Suppose we have proven that for all job sets $X$ of size no greater than $n$ the permutation which sorts the jobs by descending $b_i$ breaking ties by descending $a_i$ is an optimal solution (bearing in mind that there may be more than one optimal solution). (Call this ordering doubly-reverse-lexicographical because it sorts in descending order starting from the right).
Consider a job set $Y$ of size $n+1$ whose "worst" job is $J_{n+1}$, and suppose that there is no optimal solution in which this job comes first. Of the optimal solutions select one which puts $J_{n+1}$ as early as possible, in position $j^* = \pi^{-1}(n+1) > 0$. Now, which $j$ maximises the expression above (i.e. which job finishes last)?
Given that $b_{\pi(j^*)}$ is maximal by construction and the sum is non-decreasing the maximising $j$ must be $\ge j^*$. Also, if the maximising $j > j^*$ we can move $J_{n+1}$ to the start without affecting the optimality, so by contradiction that's impossible. We're forced to conclude that $J_{n+1}$ is the job which finishes last.
Now consider what happens if we swap it with the job before it. Call that job $J_p$ for previous. $J_p$'s finishing time increases from $b_p + \sum_{k < j^*}a_{\pi(k)}$ to $b_p + \sum_{k \le j^*}a_{\pi(k)} \le b_{n+1} + \sum_{k \le j^*}a_{\pi(k)}$ and $J_{n+1}$'s finishing time decreases from $b_{n+1} + \sum_{k \le j^*}a_{\pi(k)}$ to $b_{n+1} + \sum_{k \le j^* \wedge k \ne j^*-1}a_{\pi(k)}$ so we have a contradiction with this being an optimal solution which puts $J_{n+1}$ as early as possible.
We've now proven that there is an optimal solution for $Y$ in which $J_{n+1}$ comes first. Either some of these optimal solutions allow for the rest of the jobs to be ordered non-optimally because the worst job is so bad that it doesn't matter – in which case putting them in an optimal ordering will give an optimal ordering – or the rest of the jobs must be optimally ordered to get an optimal ordering. In either case we can apply our strong inductive presupposition to say that there is an optimal ordering which is doubly-reverse-lexicographical.
The base case of only one job is trivial.
NB: in my understanding a problem labelled "integer" means that it has integer solutions only, and is unrelated to what if any limits are placed on those integers. The $0-1$ knapsack problem is integer, an integer knapsack problem is not necessarily the $0-1$. This is usually clarified by differentiating between the $0-1$ problem and the unbounded problem.
Your understanding on the difference between an integer and fractional problem (terminology I have been educated with: "discrete" and "continuous", respectively) is correct. A discrete problem allows only the choices of taking the object or leaving it, while a continuous problem allows for taking part of an object and leaving the remainder of it.
Your understanding of a greedy algorithm is also broadly accurate, but may need some clarification. The solution involves taking the best thing we are able at this point to take, until we reach one of the limits imposed by the problem (be it achieving maximum, or running out of objects to take). It does not necessarily involve repetition of any objects, and interestingly, can give the absolute worst solution when applied to problems with certain constraints.
Before we begin on the proof, I'm also going to define density as the value of an object divided by the volume of that object, so that we're all on the same understanding.
The proof runs as follows: say you've got a perfect solution that doesn't involve taking all the highest-density object you possibly can, so there's some amount of a lower-density object taking up space in the solution, and some amount of highest-density object left out. If you were to swap as much as you could of the lower-density object with the higher-density one (which is determined by the smaller of: volume of lower-density object taken, volume of higher-density left out) then you would increase the overall value of that volume: $density x volume = value$, so increasing $density$ and maintaining $volume$ means increasing $value$. But then you've got a better-than-perfect solution - which is a contradiction. So the perfect solution must require taking as much as possible of the highest-density object.
The second part of the proof is simply applying this concept to a particular case of the lower-density object: empty space with a value of zero. If any highest-density object is left out, you perform the same swap as above, and thereby increase the overall value. That contradicts the fact that some volume is empty while some highest-density object is left out, so you have a similar result.
Finally the continuous knapsack problem is solved optimally by the greedy algorithm, by applying the above proven concept iteratively. In terms of real objects in a real knapsack, think of this as the "pockets answer".
Your initial solution must include taking as much of the highest-density object as you can. If that "fills the knapsack" then you're done; if you've taken all the highest-density object and have empty space left over, then you create a new knapsack problem: ignore the highest-density object and the volume taken up by it. That is, ignore the pockets you've already filled, and treat the remaining pockets as a separate knapsack to fill!
This means the new solution must include taking as much of the new highest-density object as possible. Now repeat the process until either you've got no empty space or you've got no objects left out. Each part has taken the largest value it possibly can, so altogether, the entire knapsack has the highest possible value as well. And then you're done.
Best Answer
As Brian Tung writes in a comment, "greedy algorithm" is not really a crisp technical term, but more of a fuzzy concept that can be helpful for remembering and categorizing algorithms in your mind, and for getting ideas for how to possibly approach a new problem. There are essentially no cases where it makes any technical difference whether you call this-or-that algorithm greedy or not.
That being said, I wouldn't call algorithm (b) a "greedy algorithm" myself, but it's not completely crazy to do so either.
In general, if I were to describe what a greedy algorithm means, my first attempt would be something on the lines of
That certainly describes algorithm (a) -- the rule is simple and selects the way to increase the number-of-skis delivered that leads to the smallest value so far for the sum we want to minimize. That's a reasonable way to measure immediate progress.
On the other hand, if I want to shoehorn (b) into the "greedy paradigm" I would need to weaken my description into
The rule in algorithm (b) is surely simple enough, but it's hard to justify the rule as a short-sighted way to find the most immediate progress -- unless we cheat and already know that the rule happens to construct an optimal solution anyway.
On the other hand, algorithms that match the weakened desciption still have some relevant features in common with actual greedy algorithms -- among which is that the tactics that are useful for proving greedy strategies optimal (when they are indeed optimal), such as exchange arguments, can also be useful to reason about the wider group of algorithms.
So in this sense it is "not completely crazy" to describe (b) as a greedy algorithm, because it can still point towards useful ways to think and reason about the algorithm.