What I would try when trying to implement default folding is: search backward for a blank line (or folded line), then from there search forward for the first opening brace at end of line.  When found, then find the matching closing brace, and fold from the blank or folded line to the closing brace.  When a blank line is encountered before an opening brace is found, just fold from the first blank or folded line to the found blank line.  (Of course, this kind of folding works only for C-like programs and for plain text where paragraphs are separated by blank lines, but... it's a start.)

+                        } else if(index == FOLDED_LINE) {

Coloring things is not an essential part of folding.  It can be added later.  Now it just clutters the patch.

+#ifndef NANO_TINY
+        bool was_folded = openfile->current->folded;
+#endif

Don't use a variable that isn't needed to make things work.  It's just clutter.

+                if (was_folded) {
+                        unfold_segment(openfile->current);
+                        refresh_needed = TRUE;
+                }

Is there any situation where one doesn't need to do a refresh when one folds or unfolds?  I can't think of any.  So setting 'refresh_needed' should just be part of the folding and unfolding routines.  Then the above can be just two lines instead of four.  Yes: nano's style is not to use braces for a single statement.

+        if (top != bot) {

Again: do not add braces where they are not needed.  And certainly don't add braces where they weren't before.

+        add_to_sclist(MMAIN, "^E", 0, do_fold_segment, 0);

^E is already taken.  You have to pick a keystroke that is not ued yet.  I would suggest M-[, which even looks a bit mnemonic.

...

+/* Add a new folded segment holding the range [start,end] */

The comment does not match the code any more.

+        linestruct *l = line;

Ouch.  Why not just use 'line'?

+int fold_segment_length(linestruct *line)

Poor function name.  I read 'fold' as a verb here.

...

+#ifndef NANO_TINY
+                if (line->folded) {
+                        line = get_end_of_folded_segment(line);
+                        line = line->next;
+                } else
+#endif
+                {
+                        line = line->next;
+                }

Ugh.  This could simply be:

+#ifndef NANO_TINY
+                while (line->folded)
+#endif
+                        line = line->next;

Now about how things work.  If, with your patch, I run 'src/nano +1 README.hacking' and then type Ctrl+Shift+Down three times and then type M-[ (I've adjusted the patch to use this keystroke), then... the top line stays highlighted, and it says that 8 lines are folded.  I would have expeted 10 lines to be folded -- that is: all lines that were visibly marked, the same way that M-3 (commenting) works.

Further, if I type M-[ while nothing is marked, nothing happens.  I would expect M-[ to do something by default.  For example, fold the current paragraph or function, so that with multiple M-[s multiple paragraphs or functions can be folded.

If you make an improved patch, please send it to nano-devel.  Other people will see it, and it's much easier to review -- I won't need to copy stuff over.

I know it's a huge patch, I was trying to keep it small but I kept having issues where different functionality wouldn't handle the cursor placement or unfolding when necessary. I apologize for that.

To address your points:
1) Yeah I wasn't happy with adding a whole pointer to linestruct myself. I initially had it as just a linked list in the openfile struct without having the pointer in the linestruct, but then when finding which fold the line was in it would iterate through the list of fold segments checking each one by one. I hadn't thought to just put a bool in the linestruct to make lookup for non-folded lines just return early. That could be changed easily to just be a bool.

2) Fair enough. It made sense to me when making it, but 'unfold_segment' is a way better name looking at it now.

Folding lines is the ability to hide or collapse a section of a file when you don't need to see it. All IDEs I've used have had this feature and it's the one thing I feel GNU nano has been missing when working from the terminal. It helps to keep the screen less cluttered when trying to focus.
Folding lines is useful when trying to work on two parts of a file at the same time, or when referencing something in a different section of the same file instead of jumping back and forth.

I also found this bug report before I began implementing line folding, which told me I'm not the only one who would like to see this implemented:
bug #58199: [Wish] the ability to temporarily "fold" lines

I've been using this folding feature for a couple days working on C++ files and it seems stable. I didn't add any self-crediting in the patch or update translations. I assume that would be taken care of separately if this is ever accepted.