05AB1E, 14 bytes

Saved 1 byte thanks to Kevin Cruijssen

ā<æʒĆ¥≠W}èΣO}θ

Try it online!
or as a Test Suite

Explanation

ā<               # push [0 ... len(input)-1]

  æ              # compute powerset

   ʒ    }        # filter, keep lists where:

      ≠W         # no element is 1 in the

     ¥           # deltas

    Ć            # of the list with the head appended

         è       # index into the input with each

          ΣO}    # sort by sum

             θ   # take the last element

Brachylog (v2), 14 bytes

{~ba~c∋₁ᵐ}ᶠ+ᵒt

Try it online!

Function submission; input from the left, output from the right, as usual. Very slow; a five-element list is probably the maximum for testing on TIO.

{~ba~c∋₁ᵐ}ᶠ+ᵒt

 ~b              Prepend an arbitrary element to the input

   a             Take a prefix or suffix of the resulting list

    ~c           Ordered partition into contiguous sublists

      ∋₁         Take the second element

        ᵐ          of each sublist

{        }ᶠ      Find all possible ways to do this

           +ᵒ    Sort by sum

             t   Take the greatest

The results we get from prefixes aren't incorrect, but also aren't interesting; all possible results are generated via taking a suffix (which is possibly the list itself, but cannot be empty), but "suffix" is more verbose in Brachylog than "prefix or suffix", so I went with the version that's terser (and less efficient but still correct). The basic idea is that for each element we want in the output list, the partition into contiguous sublists needs to place that element and the element before into the same sublist (because the element is the second element of the sublist), so two consecutive elements can't appear in the result. On the other hand, it's fairly clear that any list without two consecutive elements can appear in the result. So once we have all possible candidate lists, we can just take the sums of all of them and see which one is largest.

JavaScript (ES6),  138 132 130 129  126 bytes

Outputs key-value pairs.

a=>a.reduce((a,x,i)=>[...a,...a.map(y=>[[x,i],...y])],[[]]).map(m=a=>a.some(s=p=([v,i])=>p-(s=~~s+v,p=i)<2)|s<m||(r=a,m=s))&&r

Try it online!

Step 1

We first compute the powerset of the input with $[value, index]$ pairs.

a.reduce((a, x, i) => // for each value x at position i:

  [                   //   update a[] to a new array consisting of:

    ...a,             //     all previous entries

    ...a.map(y =>     //     for each value y in a[]:

      [[x, i], ...y]  //       append [x, i], followed by all original entries

    )                 //     end of map()

  ],                  //   end of new array

  [[]]                //   start with a = [[]]

)                     // end of reduce()

Step 2

We then look for the maximum sum $m$ among these sets, discarding sets with at least two adjacent elements. The best set is stored in $r$.

.map(m =              // initialize m to a non-numeric value

  a =>                // for each entry a[] in the powerset:

  a.some(s = p =      //   initialize s and p to non numeric values

    ([v, i]) =>       //   for each value v and each index i in a[]:

    p - (             //     compute p - i

      s = ~~s + v,    //     add v to s

      p = i           //     update p to i

    ) < 2             //     if p - i is less than 2, yield true

  ) |                 //   end of some()

  s < m ||            //   unless some() was truthy or s is less than m,

  (r = a, m = s)      //   save a[] in r[] and update m to s

) && r                // end of map(); return r[]

Wolfram Language (Mathematica), 144 bytes

If[Max[a=#]>(d=Max[m=Tr/@(g=a[[#]]&/@Select[Subsets[Range[x=Length@#],{2,x}]&@#,FreeQ[Differences@#,1]&]&@a)]),{Max@a},g[[#]]&@@@Position[m,d]]&

Try it online!

Pyth, 19 bytes

esDm@LQdtf!q#1.+TyU

Try it online here, or verify all the test cases at once here.

esDm@LQdtf!q#1.+TyUQ   Implicit: Q=eval(input())

                       Trailing Q inferred

                  UQ   Generate range [0-len(Q))

                 y     Take the powerset of the above

         f             Filter keep elements of the above, as T, using:

              .+T        Take differences of consecutive elements of T

           q#1           Keep those differences equal to 1

          !              Logical NOT - empty lists evaluate to true, populated ones to false

                       Result of the filter is those sets without consecutive numbers

        t              Drop the first element (empty set)

   m                   Map the remaining sets, as d, using:

     L d                 For each element of d...

    @ Q                  ... get the element in Q with that index

 sD                    Order the sets by their sum

e                      Take the last element, implicit print

Husk, 11 bytes

►Σ†!¹mü≈tṖŀ

Try it online!

Explanation

►Σ†!¹mü≈tṖŀ  Implicit input, say L=[4,5,3,4].

          ŀ  Indices: [1,2,3,4]

         Ṗ   Powerset: [[],[1],[2],[1,2],..,[1,2,3,4]]

        t    Tail (remove the empty list): [[1],[2],[1,2],..,[1,2,3,4]]

     m       For each,

      ü      de-duplicate by

       ≈     differing by at most 1.

             For example, [1,2,4] becomes [1,4].

  †          Deep map

   !¹        indexing into L: [[4],[5],[4],..,[5,4],[4,3]]

►            Maximum by

 Σ           sum: [5,4]

Haskell, 300 168 bytes

import Data.List

h[]=1>2

h(x:y)=fst$foldl(a c->((fst a)&&(c-snd a>1),c))(1<2,x)y

z=snd.last.sortOn fst.map((,)=<<sum.snd).filter(h.fst).map unzip.subsequences.zip[0..]

Try it online!

-132 bytes thanks to all the feedback from @nimi :)

Original

Ungolfed (original)

import Data.List

import Data.Function



f :: [Int] -> [(Int, Int)] -- attach indices for later use

f [] = []

f xs = zip xs [0..length xs]



g :: [[(Int, Int)]] -> [([Int], [Int])] -- rearrange into list of tuples

g [] = []

g (x:xs) = (map fst x, map snd x) : g xs



h :: [Int] -> Bool -- predicate that checks if the indices are at least 2 apart from each other

h [] = False

h (x:xs) = fst $ foldl (acc curr -> ((fst acc) && (curr - snd acc > 1), curr)) (True, x) xs

j :: [([Int], [Int])] -> [([Int], [Int])] -- remove sets that don't satisfy the condition

j xs = filter ((elements, indices) -> h indices) xs



k :: [([Int], [Int])] -> [(Int, ([Int], [Int]))] -- calculate some of elements

k xs = map ((elements, indices) -> (foldl1 (+) elements, (elements, indices))) xs



l :: [(Int, ([Int], [Int]))] -> ([Int], [Int]) -- grab max

l xs = snd $ last $ sortBy (compare `on` fst) xs



z -- put things together

```

Jelly, 16 14 bytes

JŒPḊf’$ÐḟịµSÞṪ

Try it online!

Thanks to @EriktheOutgolfer for saving 2 bytes!

Charcoal, 46 bytes

≔⟦υ⟧ηＦθ«≔υζ≔Ｅη⁺κ⟦ι⟧υ≔⁺ζηη»≔Φ⁺υηιη≔ＥηΣιζＩ§η⌕ζ⌈ζ

Try it online! Link is to verbose version of code. Explanation:

≔⟦υ⟧η

The variable u is predefined with an empty list. This is put in a list which is assigned to h. These variables act as accumulators. u contains the sublists that include the latest element of the input q while h contains the sublists that do not (and therefore are suitable for appending the next element of the input).

Ｆθ«

Loop over the elements of the input.

≔υζ

Save the list of sublists that contain the previous element.

≔Ｅη⁺κ⟦ι⟧υ

Take all of the sublists that do not contain the previous element, append the current element, and save the result as the list of sublists that contain the current element. (I don't use Push here as I need to clone the list.)

≔⁺ζηη»

Concatenate both previous sublists into the new list of sublists that do not contain the current element.

≔Φ⁺υηιη

Concatenate the sublists one last time and remove the original empty list (which Charcoal can't sum anyway).

≔ＥηΣιζ

Compute the sums of all of the sublists.

Ｉ§η⌕ζ⌈ζ

Find an index of the greatest sum and output the corresponding sublist.

Japt -h, 21 bytes

Ever have one of those challenges where you completely forget how to golf?!

ð¤à fÊk_än ø1îmgUÃñx

Try it

T-SQL, 122 bytes

Input is a table variable.

This query picks all values from the table variable, join it with all values 2 or more positions later recusively and show the text generated for the highest sum of the values.

WITH C as(SELECT i j,x y,x*1v

FROM @ UNION ALL SELECT i,y+','+x,v+x

FROM @ JOIN C ON j+1<i)SELECT

TOP 1y FROM C ORDER BY-v

Try it online ungolfed